@highfivve/ad-tag 5.5.4

package/lib/ads/adPipeline.js

@@ -0,0 +1,159 @@
+import { createLabelConfigService } from './labelConfigService';
+import { tcfapi } from '../types/tcfapi';
+import { consentReady } from './consent';
+var TCPurpose = tcfapi.responses.TCPurpose;
+import { generateAdUnitPathVariables } from './adUnitPath';
+import { createAssetLoaderService } from '../util/assetLoaderService';
+import { uuidV4 } from '../util/uuid';
+export const HIGH_PRIORITY = 100;
+export const LOW_PRIORITY = 10;
+export const mkInitStep = (name, fn) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+};
+export const mkConfigureStep = (name, fn) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+};
+export const mkConfigureStepOncePerRequestAdsCycle = (name, fn) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    let currentRequestAdsCalls = 0;
+    return mkConfigureStep(name, (context, slots) => {
+        if (currentRequestAdsCalls !== context.requestAdsCalls__) {
+            currentRequestAdsCalls = context.requestAdsCalls__;
+            return fn(context, slots);
+        }
+        else {
+            return Promise.resolve();
+        }
+    });
+};
+export const mkConfigureStepOnce = (name, fn) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    return mkConfigureStep(name, (context, slots) => context.requestAdsCalls__ === 1 && context.requestId__ === 1
+        ? fn(context, slots)
+        : Promise.resolve());
+};
+export const mkPrepareRequestAdsStep = (name, priority, fn) => {
+    const step = Object.assign(fn, { priority: priority });
+    Object.defineProperty(fn, 'name', { value: name });
+    return step;
+};
+export const mkRequestBidsStep = (name, fn) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+};
+export class AdPipeline {
+    constructor(config, logger, window, auction) {
+        this.config = config;
+        this.logger = logger;
+        this.window = window;
+        this.auction = auction;
+        this.init = null;
+        this.tcData = null;
+        this.requestId = 0;
+        this.runPrepareRequestAds = (context, definedSlots) => {
+            const byPriority = new Map();
+            this.config.prepareRequestAds.forEach(step => {
+                const steps = byPriority.get(step.priority);
+                if (steps) {
+                    steps.push(step);
+                }
+                else {
+                    byPriority.set(step.priority, [step]);
+                }
+            });
+            return (Array.from(byPriority.entries())
+                .sort(([prio1], [prio2]) => (prio1 > prio2 ? -1 : 1))
+                .reduce((prevSteps, [priority, steps]) => {
+                return prevSteps.then(() => {
+                    context.logger__.debug('AdPipeline', context.requestId__, `run prepareRequestAds with priority ${priority}`);
+                    return Promise.all(steps.map(step => step(context, definedSlots)));
+                });
+            }, Promise.resolve(undefined)));
+        };
+    }
+    run(slots, config, runtimeConfig, requestAdsCalls, options) {
+        this.requestId = this.requestId + 1;
+        const currentRequestId = this.requestId;
+        const auctionId = uuidV4(this.window);
+        this.logger.debug('AdPipeline', `starting run with requestId ${currentRequestId} on ${requestAdsCalls}. call. AuctionId ${auctionId}`, slots);
+        const consentConfig = config.consent || {};
+        this.tcData = this.tcData
+            ? this.tcData
+            : consentReady(consentConfig, this.window, this.logger, runtimeConfig.environment);
+        return this.tcData.then(consentData => {
+            const extraLabels = [...(config.targeting?.labels || []), ...runtimeConfig.labels];
+            if (consentData.gdprApplies &&
+                consentData.purpose.consents[TCPurpose.STORE_INFORMATION_ON_DEVICE]) {
+                extraLabels.push('purpose-1');
+            }
+            else if (!consentData.gdprApplies) {
+                extraLabels.push('purpose-1');
+            }
+            const labelConfigService = createLabelConfigService(config.labelSizeConfig || [], extraLabels, this.window);
+            const bucketName = options?.bucketName;
+            const bucketConfig = bucketName && config.buckets?.bucket && config.buckets.bucket[bucketName]
+                ? config.buckets.bucket[bucketName]
+                : null;
+            const defaultAdUnitPathVariables = generateAdUnitPathVariables(this.window.location.hostname, labelConfigService.getDeviceLabel(), config.targeting?.adUnitPathVariables, config.domain);
+            const adUnitPathVariables = {
+                ...defaultAdUnitPathVariables,
+                ...runtimeConfig.adUnitPathVariables
+            };
+            const context = {
+                auctionId__: auctionId,
+                requestId__: currentRequestId,
+                requestAdsCalls__: requestAdsCalls,
+                logger__: this.logger,
+                env__: runtimeConfig.environment || 'production',
+                config__: config,
+                runtimeConfig__: runtimeConfig,
+                labelConfigService__: labelConfigService,
+                window__: this.window,
+                tcData__: consentData,
+                bucket__: bucketConfig,
+                adUnitPathVariables__: adUnitPathVariables,
+                auction__: this.auction,
+                assetLoaderService__: createAssetLoaderService(this.window),
+                options__: options
+            };
+            this.init = this.init
+                ? this.init
+                : this.logStage('init', currentRequestId).then(() => Promise.all(this.config.init.map(step => step(context))));
+            const REJECTED_NO_SLOTS_AFTER_FILTERING = 'rejected-no-slots-after-filtering';
+            return this.init
+                .then(() => this.logStage('configure', currentRequestId).then(() => Promise.all(this.config.configure.map(step => step(context, slots)))))
+                .then(() => this.logStage('defineSlots', currentRequestId).then(() => this.config.defineSlots(context, slots)))
+                .then(definedSlots => {
+                if (!definedSlots.length) {
+                    return Promise.reject(REJECTED_NO_SLOTS_AFTER_FILTERING);
+                }
+                return (this.logStage('prepareRequestAds', currentRequestId)
+                    .then(() => this.runPrepareRequestAds(context, definedSlots))
+                    .then(() => this.logStage('requestBids', currentRequestId))
+                    .then(() => Promise.all(this.config.requestBids.map(step => step(context, definedSlots))))
+                    .then(() => this.logStage('requestAds', currentRequestId))
+                    .then(() => this.config.requestAds(context, definedSlots)));
+            })
+                .catch(error => {
+                switch (error) {
+                    case REJECTED_NO_SLOTS_AFTER_FILTERING:
+                        return Promise.resolve();
+                    default:
+                        this.logger.error('AdPipeline', 'running ad pipeline failed with error', error);
+                        return Promise.reject(error);
+                }
+            });
+        });
+    }
+    getAuction() {
+        return this.auction;
+    }
+    logStage(stageName, requestId) {
+        return new Promise(resolve => {
+            this.logger.debug('AdPipeline', requestId, `stage: ${stageName}`);
+            resolve();
+        });
+    }
+}

package/lib/ads/adService.js

@@ -0,0 +1,251 @@
+import { getDefaultLogger, getLogger, ProxyLogger } from '../util/logging';
+import { AdPipeline } from './adPipeline';
+import { gptConfigure, gptConsentKeyValue, gptDefineSlots, gptDestroyAdSlots, gptInit, gptLDeviceLabelKeyValue, gptRequestAds, gptResetTargeting } from './googleAdManager';
+import domready from '../util/domready';
+import { prebidClearAuction, prebidConfigure, prebidDefineSlots, prebidInit, prebidPrepareRequestAds, prebidRemoveAdUnits, prebidRenderAds, prebidRequestBids } from './prebid';
+import { a9Configure, a9Init, a9RequestBids, a9ClearTargetingStep, a9PublisherAudiences } from './a9';
+import { flatten, isNotNull } from '../util/arrayUtils';
+import { executeDebugDelay, getDebugDelayFromLocalStorage } from '../util/debugDelay';
+import { createGlobalAuctionContext } from './globalAuctionContext';
+import { getDeviceLabel } from 'ad-tag/ads/labelConfigService';
+import { bridgeInitStep } from 'ad-tag/ads/bridge/bridge';
+const isManualSlot = (slot) => {
+    return slot.behaviour.loaded === 'manual';
+};
+const isInfiniteSlot = (slot) => {
+    return slot.behaviour.loaded === 'infinite';
+};
+const isBackfillSlot = (slot) => {
+    return slot.behaviour.loaded === 'backfill';
+};
+const isSlotAvailable = (_window) => (slot) => {
+    return (!!_window.document.getElementById(slot.domId) ||
+        slot.position === 'interstitial' ||
+        slot.position === 'out-of-page' ||
+        slot.position === 'out-of-page-interstitial' ||
+        slot.position === 'out-of-page-top-anchor' ||
+        slot.position === 'out-of-page-bottom-anchor');
+};
+const getBucketName = (bucket, device) => {
+    if (!bucket) {
+        return 'default';
+    }
+    if (typeof bucket === 'string') {
+        return bucket;
+    }
+    return bucket[device] || 'default';
+};
+const slotsInBucket = (_window, config, device, bucket, options) => {
+    const { loaded } = { ...{ loaded: 'manual' }, ...options };
+    return (config.slots
+        .filter(isSlotAvailable(_window))
+        .filter(slot => {
+        const slotBucket = getBucketName(slot.behaviour.bucket, device);
+        return (slotBucket === bucket &&
+            (slot.behaviour.loaded === loaded || slot.behaviour.loaded === 'infinite'));
+    })
+        .map(slot => (options?.sizesOverride ? { ...slot, sizes: options.sizesOverride } : slot)));
+};
+export class AdService {
+    static getEnvironment(config) {
+        return config.environment || 'production';
+    }
+    constructor(assetService, eventService, window, adPipelineConfig) {
+        this.assetService = assetService;
+        this.eventService = eventService;
+        this.window = window;
+        this.adPipelineConfig = adPipelineConfig;
+        this.requestAdsCalls = 0;
+        this.adPipeline = new AdPipeline({
+            init: [() => Promise.reject('AdPipeline not initialized yet')],
+            configure: [],
+            defineSlots: () => Promise.resolve([]),
+            prepareRequestAds: [],
+            requestBids: [],
+            requestAds: () => Promise.resolve()
+        }, getDefaultLogger(), this.window, createGlobalAuctionContext(this.window, getDefaultLogger(), this.eventService));
+        this.initialize = (config, runtimeConfig) => {
+            const env = AdService.getEnvironment(runtimeConfig);
+            const adServer = config.adServer || 'gam';
+            const isGam = adServer === 'gam';
+            const isSinglePageApp = config.spa?.enabled === true;
+            this.logger.setLogger(getLogger(runtimeConfig, this.window));
+            this.logger.debug('AdService', `Initializing with environment ${env} and ad server ${adServer}`);
+            const init = isGam ? [gptInit(), bridgeInitStep()] : [];
+            const configure = isGam ? [gptConfigure()] : [];
+            if (isGam && isSinglePageApp) {
+                configure.push(gptDestroyAdSlots(), gptResetTargeting());
+            }
+            const prepareRequestAds = [];
+            if (isGam) {
+                prepareRequestAds.push(gptLDeviceLabelKeyValue(), gptConsentKeyValue());
+            }
+            const requestBids = [];
+            if (config.prebid && env === 'production') {
+                init.push(prebidInit(this.assetService));
+                configure.push(prebidConfigure(config.prebid, config.schain));
+                if (isSinglePageApp) {
+                    configure.push(prebidRemoveAdUnits(config.prebid));
+                    if (config.prebid.clearAllAuctions) {
+                        configure.push(prebidClearAuction());
+                    }
+                }
+                prepareRequestAds.push(prebidPrepareRequestAds(config.prebid));
+                requestBids.push(prebidRequestBids(config.prebid, adServer));
+            }
+            if (config.a9 && env === 'production' && isGam) {
+                init.push(a9Init(config.a9, this.assetService));
+                configure.push(a9Configure(config.a9, config.schain));
+                configure.push(a9PublisherAudiences(config.a9));
+                prepareRequestAds.push(a9ClearTargetingStep());
+                requestBids.push(a9RequestBids(config.a9));
+            }
+            const globalAuctionContext = createGlobalAuctionContext(this.window, this.logger, this.eventService, config.globalAuctionContext);
+            configure.push(globalAuctionContext.configureStep());
+            init.push(...runtimeConfig.adPipelineConfig.initSteps);
+            configure.push(...runtimeConfig.adPipelineConfig.configureSteps);
+            prepareRequestAds.push(...runtimeConfig.adPipelineConfig.prepareRequestAdsSteps);
+            requestBids.push(...runtimeConfig.adPipelineConfig.requestBidsSteps);
+            if (env === 'test') {
+                const debugDelay = getDebugDelayFromLocalStorage(this.window);
+                if (debugDelay) {
+                    configure.push(() => executeDebugDelay(this.window, debugDelay));
+                }
+            }
+            this.adPipeline = new AdPipeline({
+                init,
+                configure,
+                defineSlots: isGam ? gptDefineSlots() : prebidDefineSlots(),
+                prepareRequestAds,
+                requestBids,
+                requestAds: isGam ? gptRequestAds() : prebidRenderAds()
+            }, this.logger, this.window, globalAuctionContext);
+            return new Promise(resolve => {
+                domready(this.window, () => {
+                    this.logger.debug('DOM', 'dom ready');
+                    resolve(config);
+                });
+            });
+        };
+        this.requestAds = async (config, runtimeConfig) => {
+            this.requestAdsCalls = this.requestAdsCalls + 1;
+            const { refreshSlots, refreshInfiniteSlots, refreshBuckets } = runtimeConfig;
+            const device = getDeviceLabel(this.window, runtimeConfig, config.labelSizeConfig, config.targeting);
+            const refreshSlotsFromBuckets = refreshBuckets.flatMap(bucket => slotsInBucket(this.window, config, device, bucket.bucket, bucket.options).map(slot => slot.domId));
+            this.logger.info('AdService', `RequestAds[${this.requestAdsCalls}]`, refreshSlots, refreshBuckets);
+            this.eventService.emit('beforeRequestAds', { runtimeConfig: runtimeConfig });
+            try {
+                const immediatelyLoadedSlots = config.slots
+                    .map(slot => {
+                    if (isManualSlot(slot)) {
+                        return refreshSlots.includes(slot.domId) || refreshSlotsFromBuckets.includes(slot.domId)
+                            ? slot
+                            : null;
+                    }
+                    else if (isInfiniteSlot(slot)) {
+                        return refreshInfiniteSlots.some(infiniteSlot => infiniteSlot.artificialDomId === slot.domId)
+                            ? slot
+                            : null;
+                    }
+                    else if (isBackfillSlot(slot)) {
+                        return null;
+                    }
+                    else {
+                        return slot;
+                    }
+                })
+                    .filter(isNotNull)
+                    .filter(isSlotAvailable(this.window));
+                if (config.buckets?.enabled) {
+                    const buckets = new Map();
+                    immediatelyLoadedSlots.forEach(slot => {
+                        const bucket = getBucketName(slot.behaviour.bucket, device);
+                        const slots = buckets.get(bucket);
+                        if (slots) {
+                            slots.push(slot);
+                        }
+                        else {
+                            buckets.set(bucket, [slot]);
+                        }
+                    });
+                    const result = buckets.size === 0
+                        ? this.adPipeline.run([], config, runtimeConfig, this.requestAdsCalls).then(() => [])
+                        : Promise.all(Array.from(buckets.entries()).map(([bucketId, bucketSlots]) => {
+                            this.logger.debug('AdPipeline', `running bucket ${bucketId}, slots:`, bucketSlots);
+                            return this.adPipeline
+                                .run(bucketSlots, config, runtimeConfig, this.requestAdsCalls)
+                                .then(() => bucketSlots);
+                        }));
+                    this.eventService.emit('afterRequestAds', { state: 'finished' });
+                    return result.then(slots => flatten(slots));
+                }
+                else {
+                    await this.adPipeline.run(immediatelyLoadedSlots, config, runtimeConfig, this.requestAdsCalls);
+                    this.eventService.emit('afterRequestAds', { state: 'finished' });
+                    return immediatelyLoadedSlots;
+                }
+            }
+            catch (e) {
+                this.logger.error('AdPipeline', 'slot filtering failed', e);
+                this.eventService.emit('afterRequestAds', { state: 'error' });
+                return Promise.reject(e);
+            }
+        };
+        this.getAdPipeline = () => {
+            return this.adPipeline;
+        };
+        this.setLogger = (logger) => {
+            this.logger.setLogger(logger);
+        };
+        this.logger = new ProxyLogger(getDefaultLogger());
+        if (adPipelineConfig) {
+            this.adPipeline = new AdPipeline(adPipelineConfig, this.logger, window, createGlobalAuctionContext(window, this.logger, this.eventService));
+        }
+    }
+    refreshAdSlots(domIds, config, runtimeConfig, options) {
+        if (domIds.length === 0) {
+            return Promise.resolve();
+        }
+        const { loaded } = { ...{ loaded: 'manual' }, ...options };
+        const allowedLoadingBehaviours = new Set(['infinite']);
+        if (loaded === 'eager') {
+            allowedLoadingBehaviours.add('manual');
+            allowedLoadingBehaviours.add('eager');
+        }
+        else {
+            allowedLoadingBehaviours.add(loaded);
+        }
+        const availableSlots = config.slots
+            .filter(slot => domIds.some(domId => domId === slot.domId) &&
+            allowedLoadingBehaviours.has(slot.behaviour.loaded))
+            .filter(isSlotAvailable(this.window))
+            .map(slot => (options?.sizesOverride ? { ...slot, sizes: options.sizesOverride } : slot));
+        if (domIds.length !== availableSlots.length) {
+            const slotsInConfigOnly = availableSlots.filter(slot => domIds.every(domId => domId !== slot.domId));
+            const slotsOnPageDomOnly = domIds.filter(domId => availableSlots.every(slot => slot.domId !== domId));
+            if (slotsInConfigOnly.length) {
+                this.logger.warn('AdService', 'The following slots do not exist on the page DOM.', slotsInConfigOnly);
+            }
+            if (slotsOnPageDomOnly.length) {
+                this.logger.warn('AdService', 'The following slots are not configured in the ad-tag config.', slotsInConfigOnly);
+            }
+        }
+        this.logger.debug('AdService', 'refresh ad slots', availableSlots);
+        return this.adPipeline.run(availableSlots, config, runtimeConfig, this.requestAdsCalls, {
+            options
+        });
+    }
+    refreshBucket(bucket, config, runtimeConfig, options) {
+        if (!config.buckets?.enabled) {
+            return Promise.resolve();
+        }
+        const device = getDeviceLabel(this.window, runtimeConfig, config.labelSizeConfig, config.targeting);
+        const availableSlotsInBucket = slotsInBucket(this.window, config, device, bucket, options);
+        if (availableSlotsInBucket.length === 0) {
+            this.logger.warn('AdService', 'No slots found in bucket', bucket);
+            return Promise.resolve();
+        }
+        this.logger.debug('AdService', 'refresh ad buckets', availableSlotsInBucket, config.targeting);
+        return this.adPipeline.run(availableSlotsInBucket, config, runtimeConfig, this.requestAdsCalls, { bucketName: bucket, options: options });
+    }
+}

package/lib/ads/adUnitPath.js

@@ -0,0 +1,37 @@
+import { extractTopPrivateDomainFromHostname } from '../util/extractTopPrivateDomainFromHostname';
+export const removeChildId = (adUnitPath) => {
+    const [_, networkIds, ...rest] = adUnitPath.split('/');
+    const [parentNetworkId, ...childIds] = networkIds.split(',');
+    return childIds.length === 0 ? adUnitPath : ['', parentNetworkId, ...rest].join('/');
+};
+export const resolveAdUnitPath = (adUnitPath, adUnitPathVariables) => {
+    const paramsPattern = /[^{]+(?=})/g;
+    const validCharactersPattern = /([A-Za-z0-9\_]+)/g;
+    const extractedParams = adUnitPath.match(paramsPattern);
+    if (!adUnitPathVariables || !extractedParams) {
+        return adUnitPath;
+    }
+    extractedParams.forEach(param => {
+        const validParam = param.match(validCharactersPattern);
+        if (!validParam) {
+            throw new SyntaxError(`invalid variable "${param}" in path`);
+        }
+        if (!adUnitPathVariables[param]) {
+            throw new ReferenceError(`path variable "${param}" is not defined`);
+        }
+    });
+    return adUnitPath.replace(new RegExp(Object.keys(adUnitPathVariables)
+        .map(key => `{${key}}`)
+        .join('|'), 'g'), match => adUnitPathVariables[match.substr(1, match.length - 2)]);
+};
+export const withDepth = (adUnitPath, depth) => {
+    const adUnitPathSegments = adUnitPath.split('/');
+    return adUnitPathSegments.slice(0, depth + 1).join('/');
+};
+export const generateAdUnitPathVariables = (hostname, device, varsFromConfig, domainFromConfig) => ({
+    ...{
+        device: device,
+        domain: domainFromConfig || extractTopPrivateDomainFromHostname(hostname) || 'unknown'
+    },
+    ...varsFromConfig
+});

package/lib/ads/auctions/adRequestThrottling.js

@@ -0,0 +1,22 @@
+export const createAdRequestThrottling = (config, _window) => {
+    const slotsRequested = new Set();
+    function onSlotRequested(event) {
+        const slotId = event.slot.getSlotElementId();
+        const shouldAddSlot = !config.includedDomIds ||
+            config.includedDomIds.length === 0 ||
+            config.includedDomIds.includes(slotId);
+        if (shouldAddSlot) {
+            slotsRequested.add(slotId);
+            _window.setTimeout(() => {
+                slotsRequested.delete(slotId);
+            }, config.throttle * 1000);
+        }
+    }
+    function isThrottled(slotId) {
+        return slotsRequested.has(slotId);
+    }
+    return {
+        onSlotRequested,
+        isThrottled
+    };
+};

package/lib/ads/auctions/biddersDisabling.js

@@ -0,0 +1,90 @@
+export const createBiddersDisabling = (config, window, logger) => {
+    const participationInfo = new Map();
+    logger?.info(`Bidders disabling feature is ${config.enabled ? 'enabled' : 'disabled'}`);
+    const isBidderDisabled = (domId, bidderCode) => {
+        if (config.excludedPositions?.includes(domId)) {
+            return false;
+        }
+        return participationInfo.get(domId)?.get(bidderCode)?.disabled ?? false;
+    };
+    const onAuctionEnd = (auction) => {
+        auction.bidderRequests?.forEach(bidderRequest => {
+            bidderRequest?.bids?.forEach(bid => {
+                const bidderCode = bid.bidder;
+                const adUnitCode = bid.adUnitCode;
+                if (!participationInfo.get(adUnitCode)) {
+                    participationInfo.set(adUnitCode, new Map());
+                }
+                const bidderState = participationInfo.get(adUnitCode)?.get(bidderCode);
+                if (bidderState) {
+                    const newBidRequestCount = bidderState.bidRequestCount + 1;
+                    participationInfo.get(adUnitCode)?.set(bidderCode, {
+                        ...bidderState,
+                        bidRequestCount: newBidRequestCount
+                    });
+                }
+                else {
+                    participationInfo.get(adUnitCode)?.set(bidderCode, {
+                        disabled: false,
+                        bidRequestCount: 1,
+                        bidReceivedCount: 0
+                    });
+                }
+            });
+        });
+        auction.bidsReceived?.forEach(bidReceived => {
+            const bidderForPosition = bidReceived.bidderCode;
+            const position = bidReceived.adUnitCode;
+            const bidderState = participationInfo.get(position)?.get(bidderForPosition);
+            if (bidderState) {
+                participationInfo.get(position)?.set(bidderForPosition, {
+                    ...bidderState,
+                    bidReceivedCount: bidderState.bidReceivedCount + 1
+                });
+            }
+            else {
+                participationInfo.get(position)?.set(bidderForPosition, {
+                    disabled: false,
+                    bidRequestCount: 1,
+                    bidReceivedCount: 1
+                });
+            }
+        });
+        deactivateBidderForTTL();
+    };
+    const deactivateBidderForTTL = () => {
+        participationInfo.forEach((bidders, position) => {
+            bidders.forEach((bidderState, bidderCode) => {
+                if (shouldDisableBidder(bidderState)) {
+                    disableBidder(position, bidderCode);
+                    window.setTimeout(() => {
+                        enableBidder(position, bidderCode);
+                    }, config.reactivationPeriod);
+                }
+            });
+        });
+    };
+    const shouldDisableBidder = (bidderState) => {
+        return (bidderState.bidRequestCount > config.minBidRequests &&
+            bidderState.bidReceivedCount / bidderState.bidRequestCount < config.minRate &&
+            !bidderState.disabled);
+    };
+    const disableBidder = (position, bidderCode) => {
+        const bidderState = participationInfo.get(position)?.get(bidderCode);
+        if (bidderState) {
+            bidderState.disabled = true;
+            logger?.info(`Bidder ${bidderCode} for position ${position} is now disabled.`);
+        }
+    };
+    const enableBidder = (position, bidderCode) => {
+        const bidderState = participationInfo.get(position)?.get(bidderCode);
+        if (bidderState) {
+            bidderState.disabled = false;
+            logger?.info(`Bidder ${bidderCode} for position ${position} is now enabled.`);
+        }
+    };
+    return {
+        isBidderDisabled,
+        onAuctionEnd
+    };
+};