@highfivve/ad-tag 5.5.4

package/lib/ads/moli.js

@@ -0,0 +1,645 @@
+import { parseQueryString } from '../util/query';
+import { AssetLoadMethod, createAssetLoaderService } from '../util/assetLoaderService';
+import { getLogger } from '../util/logging';
+import { addNewInfiniteSlotToConfig } from '../util/addNewInfiniteSlotToConfig';
+import { AdService } from './adService';
+import { createEventService } from './eventService';
+import { getActiveEnvironmentOverride, setEnvironmentOverrideInStorage } from '../util/environmentOverride';
+import { packageJson } from '../gen/packageJson';
+import * as adUnitPath from './adUnitPath';
+import { extractTopPrivateDomainFromHostname } from '../util/extractTopPrivateDomainFromHostname';
+import { createLabelConfigService } from './labelConfigService';
+import { allowRefreshAdSlot, allowRequestAds } from './spa';
+export const createMoliTag = (window) => {
+    const assetLoaderService = createAssetLoaderService(window);
+    const eventService = createEventService();
+    const adService = new AdService(assetLoaderService, eventService, window);
+    const moliWindow = window;
+    let state = {
+        state: 'configurable',
+        initialize: false,
+        runtimeConfig: newEmptyRuntimeConfig(),
+        modules: []
+    };
+    function setTargeting(key, value) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.keyValues[key] = value;
+                break;
+            }
+            case 'spa-finished':
+            case 'spa-requestAds': {
+                state.nextRuntimeConfig.keyValues[key] = value;
+                break;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting key-value after configuration: ${key} : ${value}`);
+                break;
+            }
+        }
+    }
+    function addLabel(label) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.labels.push(label);
+                break;
+            }
+            case 'spa-requestAds':
+            case 'spa-finished': {
+                state.nextRuntimeConfig.labels.push(label);
+                break;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Adding label after configure: ${label}`);
+                break;
+            }
+        }
+    }
+    function setAdUnitPathVariables(variables) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.adUnitPathVariables = variables;
+                break;
+            }
+            case 'spa-requestAds':
+            case 'spa-finished': {
+                state.nextRuntimeConfig.adUnitPathVariables = variables;
+                break;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `Setting unit path variables after configuration: ${variables}`);
+                break;
+            }
+        }
+    }
+    function getAdUnitPathVariables() {
+        const domain = extractTopPrivateDomainFromHostname(window.location.hostname) || 'unknown';
+        switch (state.state) {
+            case 'configurable':
+                return { ...state.runtimeConfig.adUnitPathVariables, domain: domain, device: 'unknown' };
+            case 'configured':
+            case 'requestAds':
+            case 'spa-requestAds':
+            case 'spa-finished':
+            case 'finished':
+            case 'error':
+                const labelService = createLabelConfigService(state.config.labelSizeConfig || [], [], window);
+                return {
+                    ...getPageTargeting().adUnitPathVariables,
+                    domain: state.config.domain || domain,
+                    device: labelService.getDeviceLabel()
+                };
+        }
+    }
+    function resolveAdUnitPath(adUnitPathParam, options) {
+        const opts = options || {};
+        const removeNetworkChildId = opts.removeNetworkChildId || false;
+        const resolvedPath = adUnitPath.resolveAdUnitPath(adUnitPathParam, getAdUnitPathVariables());
+        return removeNetworkChildId ? adUnitPath.removeChildId(resolvedPath) : resolvedPath;
+    }
+    function setLogger(logger) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.logger = logger;
+                break;
+            }
+            default: {
+                logger.error('Setting a custom logger is not allowed after configuration');
+                break;
+            }
+        }
+    }
+    function beforeRequestAds(callback) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.hooks.beforeRequestAds.push(callback);
+                break;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to add a hook beforeRequestAds. Already configured.', state.config);
+                break;
+            }
+        }
+    }
+    function afterRequestAds(callback) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.hooks.afterRequestAds.push(callback);
+                break;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to add a hook afterRequestAds. Already configured.', state.config);
+                break;
+            }
+        }
+    }
+    function getConfig() {
+        switch (state.state) {
+            case 'configurable': {
+                return null;
+            }
+            case 'configured': {
+                return state.config;
+            }
+            case 'requestAds': {
+                return state.config;
+            }
+            case 'spa-requestAds':
+            case 'spa-finished': {
+                return state.config;
+            }
+            case 'finished': {
+                return state.config;
+            }
+            case 'error': {
+                return state.config;
+            }
+        }
+    }
+    function getRuntimeConfig() {
+        return state.runtimeConfig;
+    }
+    function getPageTargeting() {
+        return {
+            keyValues: { ...state.config?.targeting?.keyValues, ...state.runtimeConfig.keyValues },
+            labels: [...(state.config?.targeting?.labels ?? []), ...state.runtimeConfig.labels],
+            adUnitPathVariables: {
+                ...state.config?.targeting?.adUnitPathVariables,
+                ...state.runtimeConfig.adUnitPathVariables
+            }
+        };
+    }
+    function registerModule(module) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.modules.push(module);
+                return;
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('Registering a module is only allowed within the ad tag before the ad tag is configured');
+            }
+        }
+    }
+    function configure(config) {
+        switch (state.state) {
+            case 'configurable': {
+                const shouldInitialize = state.initialize;
+                const envOverride = getActiveEnvironmentOverride(window);
+                const modules = state.modules;
+                if (envOverride) {
+                    state.runtimeConfig.environment = envOverride.value;
+                }
+                if (envOverride?.source === 'queryParam') {
+                    setEnvironmentOverrideInStorage(envOverride.value, window.sessionStorage);
+                }
+                const log = getLogger(state.runtimeConfig, window);
+                log.debug('MoliGlobal', 'configure modules', config.modules ?? {});
+                modules.forEach(module => {
+                    try {
+                        module.configure__(config.modules ?? {});
+                        log.debug('MoliGlobal', `configure ${module.moduleType} module ${module.name}`, module.config__());
+                        state.runtimeConfig.adPipelineConfig.initSteps.push(...module.initSteps__());
+                        state.runtimeConfig.adPipelineConfig.configureSteps.push(...module.configureSteps__());
+                        state.runtimeConfig.adPipelineConfig.prepareRequestAdsSteps.push(...module.prepareRequestAdsSteps__());
+                        if (module.requestBidsSteps__) {
+                            state.runtimeConfig.adPipelineConfig.requestBidsSteps.push(...module.requestBidsSteps__());
+                        }
+                        if (module.prebidBidsBackHandler__) {
+                            state.runtimeConfig.adPipelineConfig.prebidBidsBackHandler.push(...module.prebidBidsBackHandler__());
+                        }
+                    }
+                    catch (e) {
+                        log.error('MoliGlobal', `failed to configure ${module.moduleType} module ${module.name}`, e);
+                    }
+                });
+                state = {
+                    state: 'configured',
+                    config: config,
+                    runtimeConfig: state.runtimeConfig,
+                    modules: modules
+                };
+                if (shouldInitialize || config.requestAds === true) {
+                    return requestAds();
+                }
+                return Promise.resolve(state);
+            }
+            case 'configured': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to configure moli tag twice. Already configured.', state.config);
+                return Promise.resolve(state);
+            }
+            case 'requestAds': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to configure moli tag twice. Already requesting ads.');
+                return Promise.resolve(state);
+            }
+            case 'finished': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to configure moli tag twice. Already finished.');
+                return Promise.resolve(state);
+            }
+            case 'error': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to configure moli tag twice. Already finished, but with an error.', state.error);
+                return Promise.resolve(state);
+            }
+        }
+        return Promise.resolve(null);
+    }
+    function requestAds() {
+        switch (state.state) {
+            case 'configurable': {
+                state.initialize = true;
+                return Promise.resolve(state);
+            }
+            case 'configured': {
+                setABtestTargeting();
+                addDomainLabel(state.config.domain);
+                const { refreshInfiniteSlots } = state.runtimeConfig;
+                let config = state.config;
+                if (refreshInfiniteSlots.length > 0) {
+                    refreshInfiniteSlots.forEach(slot => {
+                        config = addNewInfiniteSlotToConfig(config, slot.idOfConfiguredSlot, slot.artificialDomId, getLogger(state.runtimeConfig, window));
+                    });
+                }
+                const log = getLogger(state.runtimeConfig, window);
+                if (state.runtimeConfig.hooks && state.runtimeConfig.hooks.beforeRequestAds) {
+                    state.runtimeConfig.hooks.beforeRequestAds.forEach(hook => {
+                        try {
+                            hook(config, state.runtimeConfig);
+                        }
+                        catch (e) {
+                            log.error('MoliGlobal', 'beforeRequestAds hook failed', e);
+                        }
+                    });
+                }
+                const afterRequestAds = state.runtimeConfig.hooks.afterRequestAds;
+                const isSinglePageApp = config.spa?.enabled === true;
+                if (isSinglePageApp) {
+                    const requestAdsRuntimeConfig = state.runtimeConfig;
+                    const initialized = adService.initialize(config, requestAdsRuntimeConfig);
+                    state = {
+                        state: 'spa-requestAds',
+                        config: config,
+                        initialized,
+                        modules: state.modules,
+                        href: window.location.href,
+                        runtimeConfig: Object.freeze(newEmptyRuntimeConfig(state.runtimeConfig, { keepTargeting: true })),
+                        nextRuntimeConfig: newEmptyRuntimeConfig(state.runtimeConfig)
+                    };
+                    return initialized
+                        .then(() => adService.requestAds(config, requestAdsRuntimeConfig))
+                        .then(() => {
+                        const validateLocation = config.spa?.validateLocation ?? 'href';
+                        if (state.state === 'spa-requestAds' &&
+                            allowRefreshAdSlot(validateLocation, state.href, window.location)) {
+                            const { config, runtimeConfig } = state;
+                            if (state.runtimeConfig.refreshSlots.length > 0) {
+                                adService.refreshAdSlots(runtimeConfig.refreshSlots, config, runtimeConfig);
+                            }
+                            if (state.runtimeConfig.refreshBuckets.length > 0) {
+                                state.runtimeConfig.refreshBuckets.forEach(bucket => {
+                                    adService.refreshBucket(bucket.bucket, config, runtimeConfig, bucket.options);
+                                });
+                            }
+                            afterRequestAds.forEach(hook => hook('spa-finished'));
+                            const finishedState = {
+                                ...state,
+                                state: 'spa-finished',
+                                nextRuntimeConfig: newEmptyRuntimeConfig(state.runtimeConfig),
+                                runtimeConfig: newEmptyRuntimeConfig(state.runtimeConfig, { keepTargeting: true })
+                            };
+                            state = finishedState;
+                            return finishedState;
+                        }
+                        else if (state.state === 'spa-finished' || state.state === 'spa-requestAds') {
+                            getLogger(state.runtimeConfig, window).debug('MoliGlobal', 'A previous requestAds() was slower than the following requestAds() call');
+                            return state;
+                        }
+                        else {
+                            return Promise.reject(`reached invalid state [${state.state}]`);
+                        }
+                    });
+                }
+                else {
+                    state = {
+                        state: 'requestAds',
+                        config: config,
+                        modules: state.modules,
+                        runtimeConfig: Object.freeze(state.runtimeConfig)
+                    };
+                    return adService
+                        .initialize(config, state.runtimeConfig)
+                        .then(config => adService.requestAds(config, state.runtimeConfig))
+                        .then(() => {
+                        state = {
+                            state: 'finished',
+                            config: config,
+                            runtimeConfig: state.runtimeConfig,
+                            modules: state.modules
+                        };
+                        afterRequestAds.forEach(hook => hook('finished'));
+                        return Promise.resolve(state);
+                    })
+                        .catch(error => {
+                        getLogger(state.runtimeConfig, window).error('MoliGlobal', error);
+                        state = {
+                            state: 'error',
+                            config: config,
+                            runtimeConfig: state.runtimeConfig,
+                            error: error,
+                            modules: state.modules
+                        };
+                        afterRequestAds.forEach(hook => hook('error'));
+                        return Promise.resolve(state);
+                    });
+                }
+            }
+            case 'spa-requestAds':
+            case 'spa-finished': {
+                if (state.state === 'spa-requestAds') {
+                    getLogger(state.runtimeConfig, window).debug('MoliGlobal', "requestAds is being called while the previous requestAds() hasn't finished yet");
+                }
+                setABtestTargeting();
+                addDomainLabel(state.config.domain);
+                const { modules } = state;
+                const afterRequestAds = state.nextRuntimeConfig.hooks.afterRequestAds;
+                const beforeRequestAds = state.nextRuntimeConfig.hooks.beforeRequestAds;
+                const currentState = state;
+                beforeRequestAds.forEach(hook => {
+                    try {
+                        hook(currentState.config, state.runtimeConfig);
+                    }
+                    catch (e) {
+                        getLogger(state.runtimeConfig, window).error('MoliGlobal', 'beforeRequestAds hook failed', e);
+                    }
+                });
+                const { initialized, href, nextRuntimeConfig } = state;
+                state = {
+                    ...currentState,
+                    state: 'spa-requestAds',
+                    runtimeConfig: newEmptyRuntimeConfig(state.nextRuntimeConfig, { keepTargeting: true }),
+                    nextRuntimeConfig: newEmptyRuntimeConfig(state.runtimeConfig)
+                };
+                return initialized
+                    .then(config => {
+                    const validation = config.spa?.validateLocation ?? 'href';
+                    if (!allowRequestAds(validation, href, window.location)) {
+                        return Promise.reject(`You are trying to refresh ads on the same page, which is not allowed. Using ${validation} for validation.`);
+                    }
+                    return adService.requestAds(config, nextRuntimeConfig).then(() => config);
+                })
+                    .then(config => {
+                    const runtimeConfig = state.runtimeConfig;
+                    if (state.runtimeConfig.refreshSlots.length > 0) {
+                        adService.refreshAdSlots(state.runtimeConfig.refreshSlots, config, state.runtimeConfig);
+                    }
+                    if (state.runtimeConfig.refreshBuckets.length > 0) {
+                        state.runtimeConfig.refreshBuckets.forEach(bucket => {
+                            adService.refreshBucket(bucket.bucket, config, runtimeConfig, bucket.options);
+                        });
+                    }
+                    state = {
+                        state: 'spa-finished',
+                        config: config,
+                        initialized,
+                        modules,
+                        href: window.location.href,
+                        runtimeConfig: state.runtimeConfig,
+                        nextRuntimeConfig: newEmptyRuntimeConfig(state.runtimeConfig)
+                    };
+                    afterRequestAds.forEach(hook => hook('spa-finished'));
+                    return state;
+                });
+            }
+            case 'requestAds': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to requestAds twice. Already requesting ads.');
+                return Promise.reject();
+            }
+            case 'finished': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to requestAds twice. Already finished.');
+                return Promise.reject();
+            }
+            case 'error': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Trying to requestAds twice. Already finished, but with an error.', state.error);
+                return Promise.reject();
+            }
+        }
+    }
+    function refreshAdSlot(domId, options) {
+        const domIds = typeof domId === 'string' ? [domId] : domId;
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.refreshSlots.push(...domIds);
+                return Promise.resolve('queued');
+            }
+            case 'spa-requestAds':
+                state.runtimeConfig.refreshSlots.push(...domIds);
+                return Promise.resolve('queued');
+            case 'spa-finished':
+                const validateLocation = state.config.spa?.validateLocation ?? 'href';
+                if (allowRefreshAdSlot(validateLocation, state.href, window.location)) {
+                    return adService
+                        .refreshAdSlots(domIds, state.config, state.runtimeConfig, options)
+                        .then(() => 'refreshed');
+                }
+                else {
+                    state.nextRuntimeConfig.refreshSlots.push(...domIds);
+                    return Promise.resolve('queued');
+                }
+            case 'finished':
+            case 'requestAds': {
+                return adService
+                    .refreshAdSlots(domIds, state.config, state.runtimeConfig, options)
+                    .then(() => 'refreshed');
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `refreshAdSlot is not allowed in state ${state.state}`, state.config);
+                return Promise.reject(`not allowed in state ${state.state}`);
+            }
+        }
+    }
+    function refreshInfiniteAdSlot(domId, idOfConfiguredSlot) {
+        switch (state.state) {
+            case 'configurable':
+            case 'configured': {
+                state.runtimeConfig.refreshInfiniteSlots.push({
+                    artificialDomId: domId,
+                    idOfConfiguredSlot: idOfConfiguredSlot
+                });
+                return Promise.resolve('queued');
+            }
+            case 'spa-requestAds':
+                state.runtimeConfig.refreshInfiniteSlots.push({
+                    artificialDomId: domId,
+                    idOfConfiguredSlot: idOfConfiguredSlot
+                });
+                return Promise.resolve('queued');
+            case 'spa-finished':
+                const validateLocation = state.config.spa?.validateLocation ?? 'href';
+                if (allowRefreshAdSlot(validateLocation, state.href, window.location)) {
+                    state = {
+                        ...state,
+                        config: addNewInfiniteSlotToConfig(state.config, idOfConfiguredSlot, domId, getLogger(state.runtimeConfig, window))
+                    };
+                    return adService
+                        .refreshAdSlots([domId], state.config, state.runtimeConfig)
+                        .then(() => 'refreshed');
+                }
+                else {
+                    state.runtimeConfig.refreshInfiniteSlots.push({
+                        artificialDomId: domId,
+                        idOfConfiguredSlot: idOfConfiguredSlot
+                    });
+                    return Promise.resolve('queued');
+                }
+            case 'finished':
+            case 'requestAds': {
+                state = {
+                    ...state,
+                    config: addNewInfiniteSlotToConfig(state.config, idOfConfiguredSlot, domId, getLogger(state.runtimeConfig, window))
+                };
+                return adService
+                    .refreshAdSlots([domId], state.config, state.runtimeConfig)
+                    .then(() => 'refreshed');
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `refreshInfiniteAdSlot is not allowed in state ${state.state}`, state.config);
+                return Promise.reject(`not allowed in state ${state.state}`);
+            }
+        }
+    }
+    function refreshBucket(bucket, options) {
+        switch (state.state) {
+            case 'configurable': {
+                state.runtimeConfig.refreshBuckets.push({ bucket, options });
+                return Promise.resolve('queued');
+            }
+            case 'configured': {
+                state.runtimeConfig.refreshBuckets.push({ bucket, options });
+                return Promise.resolve('queued');
+            }
+            case 'spa-requestAds': {
+                state.runtimeConfig.refreshBuckets.push({ bucket, options });
+                return Promise.resolve('queued');
+            }
+            case 'spa-finished': {
+                const validateLocation = state.config.spa?.validateLocation ?? 'href';
+                if (allowRefreshAdSlot(validateLocation, state.href, window.location)) {
+                    return adService
+                        .refreshBucket(bucket, state.config, state.runtimeConfig, options)
+                        .then(() => 'refreshed');
+                }
+                else {
+                    state.runtimeConfig.refreshBuckets.push({ bucket, options });
+                    return Promise.resolve('queued');
+                }
+            }
+            case 'finished':
+            case 'requestAds': {
+                return adService
+                    .refreshBucket(bucket, state.config, state.runtimeConfig, options)
+                    .then(() => 'refreshed');
+            }
+            default: {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', `refreshAdSlot is not allowed in state ${state.state}`, state.config);
+                return Promise.reject(`not allowed in state ${state.state}`);
+            }
+        }
+    }
+    function triggerDelay() {
+        window.dispatchEvent(new CustomEvent('h5v.trigger-delay'));
+        return;
+    }
+    function getState() {
+        return state.state;
+    }
+    function openConsole(path) {
+        switch (state.state) {
+            case 'configurable': {
+                getLogger(state.runtimeConfig, window).error('MoliGlobal', 'Cannot open console before configuration');
+                break;
+            }
+            default: {
+                assetLoaderService
+                    .loadScript({
+                    assetUrl: path ??
+                        `https://highfivve.github.io/moli-ad-tag/assets/bundle/v${packageJson.version}/console.js`,
+                    loadMethod: AssetLoadMethod.TAG,
+                    name: 'moli-debugger'
+                })
+                    .catch(error => console.error('failed to load moli debugger', error));
+            }
+        }
+    }
+    function setABtestTargeting() {
+        const key = 'ABtest';
+        const params = parseQueryString(window.location.search);
+        const param = params.get(key);
+        const abTest = param ? Number(param) : Math.floor(Math.random() * 100) + 1;
+        setTargeting(key, abTest.toString());
+    }
+    function addDomainLabel(domainFromConfig) {
+        const domain = domainFromConfig || extractTopPrivateDomainFromHostname(window.location.hostname);
+        if (domain) {
+            addLabel(domain);
+        }
+    }
+    function newEmptyRuntimeConfig(previous, options) {
+        return {
+            environment: previous?.environment ?? 'production',
+            hooks: {
+                beforeRequestAds: previous?.hooks.beforeRequestAds ?? [],
+                afterRequestAds: previous?.hooks.afterRequestAds ?? []
+            },
+            logger: previous?.logger ?? undefined,
+            adUnitPathVariables: options?.keepTargeting === true ? (previous?.adUnitPathVariables ?? {}) : {},
+            labels: options?.keepTargeting === true ? (previous?.labels ?? []) : [],
+            keyValues: options?.keepTargeting === true ? (previous?.keyValues ?? {}) : {},
+            refreshSlots: [],
+            refreshInfiniteSlots: [],
+            refreshBuckets: [],
+            adPipelineConfig: {
+                initSteps: [],
+                configureSteps: [],
+                prepareRequestAdsSteps: [],
+                requestBidsSteps: [],
+                prebidBidsBackHandler: previous?.adPipelineConfig.prebidBidsBackHandler ?? []
+            }
+        };
+    }
+    const que = {
+        push(cmd) {
+            cmd(moliWindow.moli);
+        }
+    };
+    return {
+        que: que,
+        version: packageJson.version,
+        setTargeting: setTargeting,
+        addLabel: addLabel,
+        setLogger: setLogger,
+        setAdUnitPathVariables: setAdUnitPathVariables,
+        resolveAdUnitPath: resolveAdUnitPath,
+        beforeRequestAds: beforeRequestAds,
+        afterRequestAds: afterRequestAds,
+        getConfig: getConfig,
+        getRuntimeConfig: getRuntimeConfig,
+        getPageTargeting: getPageTargeting,
+        registerModule: registerModule,
+        configure: configure,
+        requestAds: requestAds,
+        refreshAdSlot: refreshAdSlot,
+        refreshBucket: refreshBucket,
+        refreshInfiniteAdSlot: refreshInfiniteAdSlot,
+        triggerDelay: triggerDelay,
+        getState: getState,
+        openConsole: openConsole,
+        addEventListener: eventService.addEventListener,
+        removeEventListener: eventService.removeEventListener
+    };
+};

package/lib/ads/moliGlobal.js

@@ -0,0 +1,11 @@
+import { createMoliTag } from './moli';
+export const initAdTag = (window) => {
+    const moliWindow = window;
+    const queueCommands = moliWindow.moli
+        ? [...moliWindow.moli.que] || []
+        : [];
+    const moli = createMoliTag(window);
+    moliWindow.moli = moli;
+    queueCommands.forEach(cmd => cmd(moli));
+    return moli;
+};

package/lib/ads/prebid-outstream.js

@@ -0,0 +1,13 @@
+import { getDefaultLogger } from '../util/logging';
+export const prebidOutstreamRenderer = (domId, url, config = {}) => ({
+    url: url,
+    render: bid => renderPrebidOutstream(bid, domId, config),
+    backupOnly: true
+});
+export const renderPrebidOutstream = (bid, domId, config = {}) => {
+    if (!bid.renderer) {
+        getDefaultLogger().error('Can not initialize prebid outstream player, because bid.renderer is not defined');
+        return;
+    }
+    bid.renderer.push(() => window.outstreamPlayer?.(bid, domId, config));
+};