@highfivve/ad-tag 5.5.4

package/lib/util/assetLoaderService.js

@@ -0,0 +1,91 @@
+import domready from '../util/domready';
+export var AssetLoadMethod;
+(function (AssetLoadMethod) {
+    AssetLoadMethod[AssetLoadMethod["FETCH"] = 0] = "FETCH";
+    AssetLoadMethod[AssetLoadMethod["TAG"] = 1] = "TAG";
+})(AssetLoadMethod || (AssetLoadMethod = {}));
+export class AssetLoaderService {
+    constructor(window) {
+        this.window = window;
+    }
+    loadScript(config, parent = this.window.document.head) {
+        return this.awaitDomReady().then(() => {
+            switch (config.loadMethod) {
+                case AssetLoadMethod.FETCH:
+                    return this.loadAssetViaFetch(config, parent);
+                case AssetLoadMethod.TAG:
+                    return this.loadAssetViaTag(config, parent);
+            }
+        });
+    }
+    loadJson(name, assetUrl) {
+        return this.window
+            .fetch(assetUrl, {
+            method: 'GET',
+            mode: 'cors',
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        })
+            .then(response => {
+            return response.ok
+                ? response.json()
+                : response
+                    .text()
+                    .then(errorMessage => Promise.reject(`${response.statusText}: ${errorMessage}`));
+        })
+            .catch(error => {
+            return Promise.reject(error);
+        });
+    }
+    loadAssetViaFetch(config, parentElement) {
+        return this.window
+            .fetch(config.assetUrl)
+            .then((response) => response.ok ? Promise.resolve(response) : Promise.reject(response))
+            .then((response) => response.text())
+            .then((body) => this.scriptTagWithBody(body))
+            .then((element) => parentElement.appendChild(element));
+    }
+    scriptTagWithBody(body) {
+        const scriptTag = this.window.document.createElement('script');
+        scriptTag.type = 'text/javascript';
+        scriptTag.async = true;
+        scriptTag.text = body;
+        return scriptTag;
+    }
+    loadAssetViaTag(config, parentElement) {
+        const tag = this.scriptTag(config);
+        return new Promise((resolve, reject) => {
+            tag.onload = resolve;
+            tag.onerror = reject;
+            parentElement.appendChild(tag);
+        });
+    }
+    scriptTag(config) {
+        const scriptTag = this.window.document.createElement('script');
+        if (config.type === 'module') {
+            scriptTag.type = 'module';
+        }
+        else if (config.type === 'nomodule') {
+            scriptTag.type = 'text/javascript';
+            scriptTag.setAttribute('nomodule', '');
+        }
+        else {
+            if (config.assetUrl.endsWith('mjs')) {
+                scriptTag.type = 'module';
+            }
+            else {
+                scriptTag.type = 'text/javascript';
+            }
+        }
+        scriptTag.async = true;
+        scriptTag.src = config.assetUrl;
+        return scriptTag;
+    }
+    awaitDomReady() {
+        return new Promise((resolve) => {
+            domready(this.window, resolve);
+        });
+    }
+}
+export const createAssetLoaderService = (window) => new AssetLoaderService(window);

package/lib/util/browserStorageKeys.js

@@ -0,0 +1,7 @@
+export const BrowserStorageKeys = {
+    moliEnv: 'moli-env',
+    moliPubCode: 'moli-pub-code',
+    moliVersion: 'moli-version',
+    testSlotSize: (id) => `moli-test-slot-size-${id}`,
+    debugDelay: 'moli-debug-delay'
+};

package/lib/util/debugDelay.js

@@ -0,0 +1,12 @@
+import { BrowserStorageKeys } from './browserStorageKeys';
+import { getBrowserStorageValue, removeBrowserStorageValue, setBrowserStorageValue } from './localStorage';
+export const executeDebugDelay = (window, delay) => delay ? new Promise(resolve => window.setTimeout(resolve, delay)) : Promise.resolve();
+export const getDebugDelayFromLocalStorage = (window) => Number(getBrowserStorageValue(BrowserStorageKeys.debugDelay, window.localStorage)) || undefined;
+export const setDebugDelayToLocalStorage = (window, value) => {
+    if (value) {
+        setBrowserStorageValue(BrowserStorageKeys.debugDelay, value.toString(), window.localStorage);
+    }
+    else {
+        removeBrowserStorageValue(BrowserStorageKeys.debugDelay, window.localStorage);
+    }
+};

package/lib/util/domready.js

@@ -0,0 +1,15 @@
+export default (window, callback) => {
+    let callbacks = [], listener, doc = typeof window.document === 'object' && window.document, hack = doc && doc.documentElement.doScroll, domContentLoaded = 'DOMContentLoaded', loaded = doc && (hack ? /^loaded|^c/ : /^loaded|^i|^c/).test(doc.readyState);
+    if (!loaded && doc) {
+        doc.addEventListener(domContentLoaded, (listener = () => {
+            if (doc) {
+                doc.removeEventListener(domContentLoaded, listener);
+                loaded = true;
+                while ((listener = callbacks.shift())) {
+                    listener();
+                }
+            }
+        }));
+    }
+    loaded ? setTimeout(callback, 0) : callbacks.push(callback);
+};

package/lib/util/environmentOverride.js

@@ -0,0 +1,16 @@
+import { BrowserStorageKeys } from './browserStorageKeys';
+import { removeBrowserStorageValue, setBrowserStorageValue } from './localStorage';
+import { updateQueryString } from './query';
+import { QueryParameters } from './queryParameters';
+import { resolveOverrides } from './resolveOverrides';
+const isEnvironmentString = (environment) => {
+    const validValues = ['production', 'test'];
+    return !!validValues.find(value => value === environment);
+};
+export const getActiveEnvironmentOverride = (window) => resolveOverrides(window, QueryParameters.moliEnv, BrowserStorageKeys.moliEnv, isEnvironmentString)[0] || undefined;
+export const setEnvironmentOverrideInStorage = (value, storage) => setBrowserStorageValue(BrowserStorageKeys.moliEnv, value, storage);
+export const resetEnvironmentOverrides = (window) => {
+    removeBrowserStorageValue(BrowserStorageKeys.moliEnv, window.sessionStorage);
+    removeBrowserStorageValue(BrowserStorageKeys.moliEnv, window.localStorage);
+    window.location.replace(updateQueryString(QueryParameters.moliEnv, undefined));
+};

package/lib/util/extractAdTagVersion.js

@@ -0,0 +1,16 @@
+export const extractAdTagVersion = ({ currentVersion }) => {
+    try {
+        switch (typeof currentVersion) {
+            case 'number':
+                return currentVersion.toFixed();
+            case 'string':
+                const num = Number(currentVersion);
+                return Number.isNaN(num) ? undefined : num.toFixed();
+            default:
+                return undefined;
+        }
+    }
+    catch (e) {
+        return undefined;
+    }
+};

package/lib/util/extractTopPrivateDomainFromHostname.js

@@ -0,0 +1,17 @@
+export const extractTopPrivateDomainFromHostname = (hostname) => {
+    if (hostname) {
+        const [tld, sub1, sub2] = hostname.split('.').reverse();
+        switch (`${sub1}.${tld}`) {
+            case 'co.uk':
+            case 'com.br':
+            case 'com.mx':
+            case 'com.au':
+                return `${sub2}.${sub1}.${tld}`;
+            default:
+                return sub1 ? `${sub1}.${tld}` : tld;
+        }
+    }
+    else {
+        return;
+    }
+};

package/lib/util/localStorage.js

@@ -0,0 +1,26 @@
+import { getDefaultLogger } from './logging';
+export const getBrowserStorageValue = (key, storage = localStorage) => {
+    try {
+        return storage.getItem(key);
+    }
+    catch (e) {
+        getDefaultLogger().debug(`Could not read value with key ${key} from browser storage`, storage);
+        return null;
+    }
+};
+export const setBrowserStorageValue = (key, value, storage = localStorage) => {
+    try {
+        storage.setItem(key, value);
+    }
+    catch (e) {
+        getDefaultLogger().debug(`Could not set key ${key} with value ${value} to browser storage`, storage);
+    }
+};
+export const removeBrowserStorageValue = (key, storage = localStorage) => {
+    try {
+        storage.removeItem(key);
+    }
+    catch (e) {
+        getDefaultLogger().debug(`Could not remove key ${key} from browser storage`, storage);
+    }
+};

package/lib/util/logging.js

@@ -0,0 +1,106 @@
+import { parseQueryString } from './query';
+export function getMoliDebugParameter(window) {
+    try {
+        const key = 'moliDebug';
+        const params = parseQueryString(window.location.search);
+        return (!!params.get(key) ||
+            !!window.sessionStorage.getItem(key) ||
+            !!window.localStorage.getItem(key));
+    }
+    catch (_) {
+        return false;
+    }
+}
+function getNoopLogger() {
+    const noop = () => {
+        return;
+    };
+    return {
+        debug: noop,
+        info: noop,
+        warn: noop,
+        error: console.error
+    };
+}
+function getLabelStyle(background) {
+    return `background:${background}; color:#FFF; padding:3px; margin:3px; border-radius:5px; line-height: 15px;`;
+}
+function getLogStageLabelStyle(logStage) {
+    switch (logStage) {
+        case 'debug':
+            return getLabelStyle('#49A0CC');
+        case 'info':
+            return getLabelStyle('#61A172');
+        case 'warn':
+            return getLabelStyle('#FFC300');
+        case 'error':
+            return getLabelStyle('#C70039');
+    }
+}
+function getSourceLabelStyle(source) {
+    switch (source) {
+        case 'AdPipeline':
+            return getLabelStyle('#74ABC6');
+        case 'GAM':
+            return getLabelStyle('#BA0E5F');
+        case 'MoliGlobal':
+            return getLabelStyle('#403073');
+        case 'Prebid':
+            return getLabelStyle('#4357AD');
+        case 'AdVisibilityService':
+            return getLabelStyle('#d5ba3c');
+        case 'UserActivityService':
+            return getLabelStyle('#19ad0e');
+        case 'Adex DMP':
+            return getLabelStyle('#003E74');
+        default:
+            return getLabelStyle('#052E53');
+    }
+}
+export function getDefaultLogger() {
+    return {
+        debug(source, message, ...optionalParams) {
+            console.debug(`%c[DEBUG]%c${source}%c${message}`, getLogStageLabelStyle('debug'), getSourceLabelStyle(source), '', ...optionalParams);
+        },
+        info(source, message, ...optionalParams) {
+            console.info(`%c[INFO]%c${source}%c${message}`, getLogStageLabelStyle('info'), getSourceLabelStyle(source), '', ...optionalParams);
+        },
+        warn(source, message, ...optionalParams) {
+            console.warn(`%c[WARN]%c${source}%c${message}`, getLogStageLabelStyle('warn'), getSourceLabelStyle(source), '', ...optionalParams);
+        },
+        error(source, message, ...optionalParams) {
+            console.error(`%c[ERROR]%c${source}%c${message}`, getLogStageLabelStyle('error'), getSourceLabelStyle(source), '', ...optionalParams);
+        }
+    };
+}
+export function getLogger(config, window) {
+    if (getMoliDebugParameter(window)) {
+        return getDefaultLogger();
+    }
+    else if (config && config.logger) {
+        return config.logger;
+    }
+    else {
+        return getNoopLogger();
+    }
+}
+export class ProxyLogger {
+    constructor(logger) {
+        this.logger = logger;
+        this.setLogger = (newLogger) => {
+            this.logger = newLogger;
+        };
+    }
+    debug(message, ...optionalParams) {
+        this.logger.debug(message, ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        this.logger.error(message, ...optionalParams);
+    }
+    info(message, ...optionalParams) {
+        this.logger.info(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        this.logger.warn(message, ...optionalParams);
+    }
+}

package/lib/util/objectUtils.js

@@ -0,0 +1,29 @@
+export const isPlainObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+export function mergeDeep(target, ...sources) {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (isPlainObject(target) && isPlainObject(source)) {
+        for (const key in source) {
+            if (isPlainObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                mergeDeep(target[key], source[key]);
+            }
+            else if (Array.isArray(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: source[key] });
+                }
+                else if (Array.isArray(target[key])) {
+                    target[key] = target[key].concat(source[key]);
+                }
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}

package/lib/util/query.js

@@ -0,0 +1,40 @@
+const parseQueryParameter = (parameter) => {
+    const valueStart = parameter.indexOf('=');
+    if (valueStart >= 0) {
+        const key = decodeURIComponent(parameter.slice(0, valueStart));
+        const value = decodeURIComponent(parameter.slice(valueStart + 1));
+        return [key, value];
+    }
+    else {
+        return [decodeURIComponent(parameter), ''];
+    }
+};
+export const parseQueryString = (search) => {
+    try {
+        const query = search.startsWith('?') ? search.slice(1) : search;
+        if (query.length > 0) {
+            return new Map(query
+                .split('&')
+                .filter(s => s.length > 0)
+                .map(parseQueryParameter));
+        }
+        else {
+            return new Map();
+        }
+    }
+    catch (e) {
+        console.error(e);
+        return new Map();
+    }
+};
+export const updateQueryString = (key, value, baseUrl, search) => {
+    baseUrl = baseUrl || [location.protocol, '//', location.host, location.pathname].join('');
+    search = search || window.location.search;
+    const newSearch = Array.from(parseQueryString(search)
+        .set(key, value || '')
+        .entries())
+        .filter(v => v[1] !== '')
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+    return [baseUrl, newSearch ? '?' : '', newSearch].join('');
+};

package/lib/util/queryParameters.js

@@ -0,0 +1,5 @@
+export const QueryParameters = {
+    moliEnv: 'moliEnv',
+    moliPubCode: 'moliPubCode',
+    moliVersion: 'moliVersion'
+};

package/lib/util/resolveOverrides.js

@@ -0,0 +1,21 @@
+import { parseQueryString } from './query';
+import { getBrowserStorageValue } from './localStorage';
+import { isNotNull } from './arrayUtils';
+export const resolveOverrides = (window, queryParam, storageKey, predicate = (value) => true) => {
+    return [
+        {
+            source: 'queryParam',
+            value: parseQueryString(window.location.search).get(queryParam)
+        },
+        {
+            source: 'sessionStorage',
+            value: getBrowserStorageValue(storageKey, window.sessionStorage)
+        },
+        {
+            source: 'localStorage',
+            value: getBrowserStorageValue(storageKey, window.localStorage)
+        }
+    ]
+        .map(({ source, value }) => (!!value && predicate(value) ? { source, value } : undefined))
+        .filter(isNotNull);
+};

package/lib/util/resolveStoredRequestIdInOrtb2Object.js

@@ -0,0 +1,12 @@
+export const resolveStoredRequestIdInOrtb2Object = (unresolvedOrtb2, storedRequestWithSolvedId) => {
+    return {
+        ...unresolvedOrtb2,
+        ext: {
+            ...unresolvedOrtb2.ext,
+            prebid: {
+                ...unresolvedOrtb2.ext?.prebid,
+                storedrequest: storedRequestWithSolvedId
+            }
+        }
+    };
+};

package/lib/util/sizes.js

@@ -0,0 +1,3 @@
+export const isSizeEqual = (size1, size2) => {
+    return size1[0] === size2[0] && size1[1] === size2[1];
+};

package/lib/util/test-slots.js

@@ -0,0 +1,150 @@
+import { SizeConfigService } from '../ads/sizeConfigService';
+import { isNotNull } from './arrayUtils';
+import { BrowserStorageKeys } from './browserStorageKeys';
+import { getBrowserStorageValue, removeBrowserStorageValue, setBrowserStorageValue } from './localStorage';
+const isTestSlotSize = (size) => size === 'hidden' ||
+    (Array.isArray(size) &&
+        size.length === 2 &&
+        typeof size[0] === 'number' &&
+        typeof size[1] === 'number');
+const testSlotContainerId = (moliSlotDomId) => `${moliSlotDomId}__container`;
+export const createTestSlots = (context, slots) => {
+    const testSlots = createBlankTestSlots(context, slots);
+    testSlots.forEach(({ slot, container }) => {
+        container.innerHTML = '';
+        container.appendChild(testSlotContent(slot));
+    });
+    return testSlots;
+};
+export const removeTestSlotSizeFromLocalStorage = (slot) => removeBrowserStorageValue(BrowserStorageKeys.testSlotSize(slot.domId));
+const setContent = (adSlotId, content) => {
+    const slotToFill = document.getElementById(adSlotId);
+    if (slotToFill) {
+        slotToFill.innerHTML = content;
+    }
+};
+const createBlankTestSlots = (context, slots) => {
+    slots.forEach(slot => {
+        const { moliSlot } = slot;
+        const containerId = testSlotContainerId(moliSlot.domId);
+        const div = document.createElement('div');
+        div.id = containerId;
+        const adSlotContainer = document.getElementById(moliSlot.domId);
+        if (adSlotContainer) {
+            adSlotContainer.setAttribute('data-google-query-id', 'test');
+        }
+        setContent(moliSlot.domId, div.outerHTML);
+        context.logger__.debug('GAM', `Set content for slot: [DomID] ${moliSlot.domId} [AdUnitPath] ${moliSlot.adUnitPath}`);
+    });
+    return queryTestSlots(slots);
+};
+const queryTestSlots = (slots) => slots
+    .map(slot => {
+    const container = document.getElementById(testSlotContainerId(slot.moliSlot.domId));
+    return container ? { slot, container } : undefined;
+})
+    .filter(isNotNull);
+const testSlotContent = (slot) => {
+    const sizes = getSizesForSlot(slot);
+    const activeSize = pickTestSlotSize(slot.moliSlot, sizes);
+    if (activeSize === 'hidden') {
+        return document.createElement('div');
+    }
+    else {
+        const content = document.createElement('div');
+        const [width, height] = activeSize;
+        content.style.cssText = `
+      position: relative; display: inline-flex; flex-direction: column; align-items: center; justify-content: center;
+      width: ${width}px; height: ${height}px; padding: 6px; border: 2px dotted gray; background-color: #fff;
+      background-image: linear-gradient(90deg, transparent 79px, #abced4 79px, #abced4 81px, transparent 81px), linear-gradient(#eee .1em, transparent .1em);
+      background-size: 100% 1.2em; box-sizing: border-box;
+    `;
+        const description = document.createElement('h4');
+        description.innerHTML = `<strong>${slot.moliSlot.domId}</strong>`;
+        content.appendChild(description);
+        const sizeDescription = document.createElement('span');
+        sizeDescription.style.color = '#656565';
+        const updateSizeDescription = ([width, height]) => (sizeDescription.innerText = `(${width}x${height})`);
+        updateSizeDescription([width, height]);
+        description.appendChild(sizeDescription);
+        const buttonContainer = document.createElement('div');
+        buttonContainer.style.cssText = `position: absolute; top: 5px; left: 5px`;
+        content.appendChild(buttonContainer);
+        const updateSize = (size, button) => {
+            if (size === 'hidden') {
+                content.style.display = 'none';
+            }
+            else {
+                const [width, height] = size;
+                content.style.width = `${width}px`;
+                content.style.height = `${height}px`;
+                updateSizeDescription(size);
+                markButtonAsActive(button);
+            }
+            saveSizeInLocalStorage(slot.moliSlot, size);
+        };
+        const defaultButtonBorder = '1px dotted white';
+        const activeButtonBorder = '1px solid black';
+        const hideButton = document.createElement('button');
+        hideButton.innerText = 'hide';
+        hideButton.title =
+            'Once hidden, it can only be restored using the moli console (or by clearing local storage manually)';
+        hideButton.style.cssText = `font-size: 10px; background: #656565; color: white; width: auto important!; border: ${defaultButtonBorder};`;
+        hideButton.addEventListener('click', () => updateSize('hidden', hideButton));
+        const buttons = [
+            ...sizes.map(buttonSize => {
+                const [width, height] = buttonSize;
+                const isActiveSize = equalsSize(activeSize, buttonSize);
+                const button = document.createElement('button');
+                button.innerText = `${width}x${height}`;
+                button.style.cssText = `font-size: 10px; background: #00a4a6; color: white; width: auto important!; border: ${isActiveSize ? activeButtonBorder : defaultButtonBorder};`;
+                button.addEventListener('click', () => updateSize(buttonSize, button));
+                return button;
+            }),
+            hideButton
+        ];
+        buttons.forEach(button => buttonContainer.appendChild(button));
+        const markButtonAsActive = (button) => {
+            buttons.forEach(button => (button.style.border = defaultButtonBorder));
+            button.style.border = activeButtonBorder;
+        };
+        return content;
+    }
+};
+const getSizesForSlot = (slot) => {
+    return slot
+        .filterSupportedSizes(slot.moliSlot.sizes)
+        .filter(SizeConfigService.isFixedSize)
+        .filter(([width, height]) => width > 1 && height > 1);
+};
+const pickTestSlotSize = (slot, sizes) => {
+    const sizeFromLocalStorage = getSizeFromLocalStorage(slot);
+    if (sizeFromLocalStorage &&
+        (sizeFromLocalStorage === 'hidden' || includesSize(sizes, sizeFromLocalStorage))) {
+        return sizeFromLocalStorage;
+    }
+    else {
+        const randomIndex = Math.floor(Math.random() * sizes.length);
+        return sizes.length === 0 ? [300, 250] : sizes[randomIndex];
+    }
+};
+const saveSizeInLocalStorage = (slot, size) => setBrowserStorageValue(BrowserStorageKeys.testSlotSize(slot.domId), JSON.stringify(size));
+const getSizeFromLocalStorage = (slot) => {
+    const localStorageValue = getBrowserStorageValue(BrowserStorageKeys.testSlotSize(slot.domId));
+    if (!localStorageValue) {
+        return undefined;
+    }
+    try {
+        const size = JSON.parse(localStorageValue);
+        return isTestSlotSize(size) ? size : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const equalsSize = (a, b) => {
+    const [widthA, heightA] = a;
+    const [widthB, heightB] = b;
+    return widthA === widthB && heightA === heightB;
+};
+const includesSize = (validSizes, size) => validSizes.some(validSize => equalsSize(validSize, size));

package/lib/util/uuid.js

@@ -0,0 +1,10 @@
+export const uuidV4 = (window) => {
+    if (typeof window.crypto?.randomUUID === 'function') {
+        return window.crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};