@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/cjs/leaveTrackingTpaas/index.js

@@ -0,0 +1,341 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateScrollPosition = exports.calculateScrolledPixels = exports.resetTpaasViewedContent = void 0;
+exports.addTpaasLeaveTracking = addTpaasLeaveTracking;
+exports.leaveTpaasTrackingIsActive = leaveTpaasTrackingIsActive;
+exports.removeTpaasLeaveTracking = removeTpaasLeaveTracking;
+exports.updateTpaasLeaveTracking = updateTpaasLeaveTracking;
+exports.trackTpaasActiveLeave = trackTpaasActiveLeave;
+exports.trackTpaasLeave = trackTpaasLeave;
+exports.getTpaasLeaveObject = getTpaasLeaveObject;
+exports.updateTpaasViewedContent = updateTpaasViewedContent;
+exports.addEventListeners = addEventListeners;
+exports.removeEventListeners = removeEventListeners;
+exports.shouldEnableLeaveTracking = shouldEnableLeaveTracking;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const logger = __importStar(require("loglevel"));
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+let currentLeaveSchema;
+let currentTrackMethod;
+let leaveListeners = [];
+let updateViewedContentListeners = [];
+let activityListeners = [];
+let resizeObserver = null;
+let throttledUpdateFn = (0, pulse_utils_1.throttle)(() => undefined, 0);
+let startTime = 0;
+let activityDuration = (0, constants_1.DEFAULT_ACTIVITY_DURATION)();
+let currentLeaveEvent = (0, constants_1.DEFAULT_PAGE_LEAVE_EVENT)();
+let additionalHeightBuilder;
+/*
+ Add leave tracking
+ */
+function addTpaasLeaveTracking({ objectElement, pageElement, schema, objectResizable, heightBuilder, trackMethod, }) {
+    function _addLeaveTracking() {
+        additionalHeightBuilder = heightBuilder;
+        addTpaasLeaveListeners();
+        addUpdateEventListeners(objectElement, pageElement || document.body, objectResizable);
+        startTime = resetTime();
+        currentLeaveSchema = schema;
+        currentTrackMethod = trackMethod;
+        logger.debug('addLeaveTracking:after:state', currentLeaveEvent);
+    }
+    if (!leaveTpaasTrackingIsActive()) {
+        // if leave tracking is not active, just start it
+        _addLeaveTracking();
+    }
+    else if (leaveTpaasTrackingIsActive() && currentLeaveSchema !== schema) {
+        // if leave tracking is active, but the schema has changed, reset and start it
+        removeTpaasLeaveTracking();
+        _addLeaveTracking();
+    }
+    else {
+        logger.warn(`addLeaveTracking was called while leave-tracking was already active for ${currentLeaveSchema}. Consider using updateLeaveTracking with resetProperties=false if you want to update the page/object element!`);
+    }
+}
+function leaveTpaasTrackingIsActive() {
+    return !(leaveListeners.length === 0 && updateViewedContentListeners.length === 0 && activityListeners.length === 0);
+}
+/*
+  Remove page leave tracking
+*/
+function removeTpaasLeaveTracking() {
+    removeLeaveListeners();
+    removeUpdateEventListeners();
+    resetEventDefaults();
+}
+/**
+ * Update leave tracking
+ * @param objectElement new object element to track
+ * @param pageElement new page element to track
+ * @param resetProperties if ALL engagement properties should be reset (duration, scroll etc.)
+ */
+function updateTpaasLeaveTracking(objectElement, pageElement, resetProperties) {
+    if (updateViewedContentListeners.length > 0) {
+        removeUpdateEventListeners();
+        if (resetProperties) {
+            resetEventDefaults();
+        }
+        addUpdateEventListeners(objectElement, pageElement);
+    }
+}
+/*
+  Add event listeners to the relevant browser events
+  When the browser event triggers, we want to send the Leave event
+  with the event supplied by the user and the name of the triggered browser event
+*/
+function addTpaasLeaveListeners() {
+    const listeners = addEventListeners([types_1.BrowserEvents.BEFORE_UNLOAD, types_1.BrowserEvents.PAGE_HIDE, types_1.BrowserEvents.POP_STATE], () => trackTpaasLeave(), { capture: true });
+    const visibilityChangeListener = addEventListeners([types_1.BrowserEvents.VISIBILITY_CHANGE], () => {
+        if (document.visibilityState === 'hidden') {
+            trackTpaasLeave();
+        }
+    }, { capture: true });
+    leaveListeners.push(...listeners);
+    leaveListeners.push(...visibilityChangeListener);
+}
+/*
+ Remove all Leave event listeners
+ */
+function removeLeaveListeners() {
+    leaveListeners = removeEventListeners(leaveListeners, { capture: true });
+}
+function removeResizeObserver() {
+    if (resizeObserver) {
+        resizeObserver.disconnect();
+        resizeObserver = null;
+    }
+}
+/*
+ Add handlers to update the default event.
+ The fields that are included can be found here: https://pages.github.schibsted.io/mpt-data/pulse-standard/#leave-article
+ */
+function addUpdateEventListeners(objectElement, pageElement, objectResizable = false) {
+    addUpdateViewedContentListeners(objectElement, pageElement, objectResizable);
+    addUpdateActivityDurationListeners();
+}
+/*
+ Remove all handlers for tracking viewed content and durations
+ */
+function removeUpdateEventListeners() {
+    updateViewedContentListeners = removeEventListeners(updateViewedContentListeners);
+    activityListeners = removeEventListeners(activityListeners);
+    removeResizeObserver();
+}
+/*
+ Reset the default leave tracking state.
+ */
+const resetEventDefaults = () => {
+    currentLeaveEvent = (0, constants_1.DEFAULT_PAGE_LEAVE_EVENT)();
+    startTime = resetTime();
+    activityDuration = resetActivityDuration();
+};
+const resetActivityDuration = () => {
+    clearInterval(activityDuration.interval);
+    return (0, constants_1.DEFAULT_ACTIVITY_DURATION)();
+};
+const resetTpaasViewedContent = () => {
+    currentLeaveEvent = (0, constants_1.DEFAULT_PAGE_LEAVE_EVENT)();
+};
+exports.resetTpaasViewedContent = resetTpaasViewedContent;
+const resetTime = () => Date.now();
+/*
+ Send a Leave event only if Page Leave tracking is active in the SDK
+ The event that is ultimately sent is a merge between the default event
+ saved in this file and the event supplied by the brand, with preference going
+ to the brand event. After the event has been sent, leave page tracking is removed
+ and must be explicitly re-added if needed.
+*/
+function trackTpaasActiveLeave() {
+    if (leaveTpaasTrackingIsActive()) {
+        trackTpaasLeave();
+    }
+}
+/*
+ Send a Leave event regardless of whether Page Leave tracking is active in the SDK
+ The event that is ultimately sent is a merge between the default event
+ saved in this file and the event supplied by the brand, with preference going
+ to the brand event. After the event has been sent, leave page tracking is removed
+ and must be explicitly re-added if needed.
+ */
+function trackTpaasLeave() {
+    const leave = getTpaasLeaveObject();
+    currentTrackMethod(leave);
+    removeTpaasLeaveTracking();
+}
+function getTpaasLeaveObject() {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+    const leave = {
+        durationMs: duration,
+        activityDurationMs: activityDuration.value,
+        ...currentLeaveEvent,
+    };
+    logger.debug('trackTpaasLeave: event', leave);
+    return leave;
+}
+/*
+ Add listeners to update the viewed content fields in the default event
+ We listen to 'scroll' and 'resize' browser events
+ */
+function addUpdateViewedContentListeners(objectElement, pageElement, objectResizable) {
+    updateTpaasViewedContent(objectElement, pageElement);
+    throttledUpdateFn = (0, pulse_utils_1.throttle)(() => updateTpaasViewedContent(objectElement, pageElement), 500);
+    updateViewedContentListeners = addEventListeners([types_1.BrowserEvents.SCROLL, types_1.BrowserEvents.RESIZE], throttledUpdateFn);
+    if (objectResizable) {
+        if (!resizeObserver) {
+            resizeObserver = new ResizeObserver(() => {
+                (0, exports.resetTpaasViewedContent)();
+                throttledUpdateFn();
+            });
+        }
+        resizeObserver.observe(objectElement);
+    }
+}
+/*
+ Update the viewed content fields that are used in the default event.
+ The includes fields are:
+ {pageScrollPosition} The absolute scroll position on the page in pixels.
+ {maxPageScrollPosition} The maximum scroll position the user has been on in pixels.
+ {objectViewPercentage} The relative scroll position of the supplied DOM element in pixels.
+ {maxObjectViewPercentage} The maximum relative scroll position of the supplied DOM element in pixels.
+ {pageViewPercentage} The relative scroll position of the user in %.
+  {maxPageViewPercentage} The maximum relative scroll position the user has seen in %.
+*/
+function updateTpaasViewedContent(objectElement, pageElement) {
+    const { totalHeight: additionalTotalHeight, viewedHeight: additionalViewedHeight } = (0, pulse_utils_1.isFunction)(additionalHeightBuilder)
+        ? additionalHeightBuilder()
+        : { totalHeight: 0, viewedHeight: 0 };
+    const objectScrolledPixels = (0, exports.calculateScrolledPixels)(objectElement) + additionalViewedHeight;
+    const pageScrolledPixels = (0, exports.calculateScrolledPixels)(pageElement) + additionalViewedHeight;
+    const pageScrollPosition = (0, exports.calculateScrollPosition)(pageElement) + additionalViewedHeight;
+    const maxPageScrollPosition = Math.max(pageScrollPosition, Number(currentLeaveEvent.maxPageScrollPosition));
+    const objectViewPercentage = calculateViewPercentage(objectScrolledPixels, objectElement.scrollHeight + additionalTotalHeight);
+    const maxObjectViewPercentage = Math.max(objectViewPercentage, Number(currentLeaveEvent.maxObjectViewPercentage));
+    const pageViewPercentage = calculateViewPercentage(pageScrolledPixels, pageElement.scrollHeight + additionalTotalHeight);
+    const maxPageViewPercentage = Math.max(pageViewPercentage, Number(currentLeaveEvent.maxPageViewPercentage));
+    logger.debug('updateViewedContent:before:engagement', { ...currentLeaveEvent });
+    currentLeaveEvent = {
+        pageScrollPosition,
+        maxPageScrollPosition,
+        objectViewPercentage,
+        maxObjectViewPercentage,
+        pageViewPercentage,
+        maxPageViewPercentage,
+    };
+    logger.debug('updateViewedContent:after:engagement', { ...currentLeaveEvent });
+}
+const calculateScrolledPixels = (element) => {
+    const rect = element.getBoundingClientRect();
+    const scrolledPixels = pulse_utils_1.isBrowser ? element.scrollHeight - rect.bottom + window.innerHeight : 0;
+    if (scrolledPixels <= 0) {
+        return 0;
+    }
+    return Math.min(scrolledPixels, element.scrollHeight);
+};
+exports.calculateScrolledPixels = calculateScrolledPixels;
+const calculateScrollPosition = (element) => Math.abs(Math.min(element.getBoundingClientRect().top, 0));
+exports.calculateScrollPosition = calculateScrollPosition;
+/*
+ Track the user's activity duration on the page.
+ The activity duration is the active time the user spends on the page.
+ Active means less than 30 seconds since the user triggered one of the
+ 'mousedown', 'mousemove', 'keydown', 'scroll' and/or 'touchstart' browser events.
+ */
+function addUpdateActivityDurationListeners() {
+    if (activityDuration.interval !== undefined) {
+        // If the interval is already set, do not set it again
+        return;
+    }
+    const interval = 1000;
+    const activityTimeout = 30 * 1000;
+    activityDuration.interval = window.setInterval(() => {
+        activityDuration.timeSinceLastActivity += interval;
+        if (activityDuration.timeSinceLastActivity < activityTimeout) {
+            activityDuration.value += interval;
+        }
+    }, interval);
+    const activityEvents = [
+        types_1.BrowserEvents.SCROLL,
+        types_1.BrowserEvents.MOUSEDOWN,
+        types_1.BrowserEvents.MOUSEMOVE,
+        types_1.BrowserEvents.KEYDOWN,
+        types_1.BrowserEvents.TOUCHSTART,
+    ];
+    activityListeners = addEventListeners(activityEvents, () => {
+        activityDuration = resetLastActivity(activityDuration);
+    }, { passive: true });
+}
+function resetLastActivity(activityDuration) {
+    return {
+        ...activityDuration,
+        timeSinceLastActivity: 0,
+    };
+}
+/*
+ Add listeners to a set of browser events.
+ */
+function addEventListeners(events, handler, options) {
+    return events.map((eventName) => {
+        if (pulse_utils_1.isBrowser) {
+            window.addEventListener(eventName, handler, options);
+        }
+        return [eventName, handler];
+    });
+}
+/*
+ Remove a set of listeners for browser events.
+ */
+function removeEventListeners(eventListeners, options = {}) {
+    for (const [eventName, listener] of eventListeners) {
+        if (pulse_utils_1.isBrowser) {
+            window.removeEventListener(eventName, listener, options);
+        }
+    }
+    throttledUpdateFn.cancel();
+    return [];
+}
+/**
+ * Calculates the fraction of an element that has been scrolled into view,
+ * rounded to 2 decimal places and clamped to the [0, 1] range.
+ */
+const calculateViewPercentage = (scrolledPixels, scrollHeight) => Math.min(1, Math.max(0, Math.round((scrolledPixels / scrollHeight) * 100) / 100));
+function shouldEnableLeaveTracking(leaveOptions) {
+    if (leaveOptions === false) {
+        return false;
+    }
+    return true;
+}

package/dist/cjs/leaveTrackingTpaas/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserEvents = void 0;
+/**
+ * @typedef BrowserEvents
+ */
+var BrowserEvents;
+(function (BrowserEvents) {
+    BrowserEvents["BEFORE_UNLOAD"] = "beforeunload";
+    BrowserEvents["PAGE_HIDE"] = "pagehide";
+    BrowserEvents["POP_STATE"] = "popstate";
+    BrowserEvents["VISIBILITY_CHANGE"] = "visibilitychange";
+    BrowserEvents["SCROLL"] = "scroll";
+    BrowserEvents["RESIZE"] = "resize";
+    BrowserEvents["MOUSEDOWN"] = "mousedown";
+    BrowserEvents["MOUSEMOVE"] = "mousemove";
+    BrowserEvents["KEYDOWN"] = "keydown";
+    BrowserEvents["TOUCHSTART"] = "touchstart";
+})(BrowserEvents || (exports.BrowserEvents = BrowserEvents = {}));

package/dist/cjs/network-browser.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = send;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const supportsBeacon = () => pulse_utils_1.isBrowser && Boolean(window.navigator.sendBeacon);
+function send(url, data, sdkConfig) {
+    // if there is as large number of events, only send 10 in each request
+    const eventChunks = Array.isArray(data)
+        ? data.reduce((acc, event) => {
+            if (acc[0].length >= 10) {
+                // biome-ignore lint/style/noParameterAssign: -
+                acc = [[event]].concat(acc);
+            }
+            else {
+                acc[0].push(event);
+            }
+            return acc;
+        }, [[]])
+        : [[data]];
+    if (pulse_utils_1.isBrowser && supportsBeacon() && (sdkConfig.useBeaconWhenAvailable || sdkConfig.useBeacon)) {
+        const result = eventChunks.reduce((previousStatus, eventChunk) => previousStatus && window.navigator.sendBeacon(url, JSON.stringify(eventChunk)), true);
+        if (result) {
+            return Promise.resolve(true);
+        }
+        return Promise.reject(false);
+    }
+    const requests = eventChunks.map((eventChunk) => fetch(url, {
+        headers: new Headers({
+            'Content-Type': 'application/x-www-form-urlencoded',
+        }),
+        method: 'POST',
+        body: JSON.stringify(eventChunk),
+    }));
+    return Promise.all(requests);
+}

package/dist/cjs/network.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = send;
+function send(url, data, state) {
+    const { username, password } = state;
+    const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
+    };
+    return fetch(url, {
+        headers,
+        method: 'POST',
+        body: JSON.stringify(data),
+    });
+}

package/dist/cjs/remoteConfig/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRemoteConfig = fetchRemoteConfig;
+exports.fetchRemoteConfigWithRetry = fetchRemoteConfigWithRetry;
+exports.readConfigFromStorage = readConfigFromStorage;
+exports.clearConfigFromStorage = clearConfigFromStorage;
+exports.clearInMemoryConfig = clearInMemoryConfig;
+exports.shouldSyncRemoteConfig = shouldSyncRemoteConfig;
+exports.resolveConfigServicesByTag = resolveConfigServicesByTag;
+exports.syncRemoteConfig = syncRemoteConfig;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const loglevel_1 = __importDefault(require("loglevel"));
+const CIS_KEY = 'cis';
+const COLLECTOR_KEY = 'collector';
+const getRemoteConfigStorageKey = '_pulse.internal.remote.config';
+let inMemoryConfig = null;
+async function fetchRemoteConfig(url) {
+    const response = await fetch(url, {
+        method: 'GET',
+    });
+    return response.json();
+}
+async function fetchRemoteConfigWithRetry(url, retries = 3) {
+    try {
+        return await fetchRemoteConfig(url);
+    }
+    catch (err) {
+        if (retries > 1) {
+            return fetchRemoteConfigWithRetry(url, retries - 1);
+        }
+        throw err;
+    }
+}
+function readConfigFromStorage() {
+    try {
+        return JSON.parse(pulse_utils_1.webApi.localStorage?.getItem(getRemoteConfigStorageKey) ?? '');
+    }
+    catch (_err) {
+        return null;
+    }
+}
+function writeConfigToStorage(config, url) {
+    try {
+        const configPersistence = {
+            config,
+            metadata: {
+                remoteConfigUrl: url,
+                updatedAt: new Date().toISOString(),
+            },
+        };
+        pulse_utils_1.webApi.localStorage?.setItem(getRemoteConfigStorageKey, JSON.stringify(configPersistence));
+        return configPersistence;
+    }
+    catch (_err) {
+        return null;
+    }
+}
+function clearConfigFromStorage() {
+    try {
+        pulse_utils_1.webApi.localStorage?.removeItem(getRemoteConfigStorageKey);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+function clearInMemoryConfig() {
+    inMemoryConfig = null;
+}
+function isConfigValid(config) {
+    const isConfigValid = !!config;
+    loglevel_1.default.debug(`RemoteConfig: isConfigValid: ${isConfigValid}`);
+    return isConfigValid;
+}
+function isConfigExpired(updatedAt, ttlMinutes) {
+    const isConfigExpired = !updatedAt || !ttlMinutes || new Date(updatedAt).getTime() + Math.min(ttlMinutes, 10080) * 60000 <= Date.now();
+    loglevel_1.default.debug(`RemoteConfig: isConfigExpired: ${isConfigExpired}`);
+    return isConfigExpired;
+}
+function shouldSyncRemoteConfig(url, config, metadata) {
+    return (!isConfigValid(config) ||
+        isConfigExpired(metadata?.updatedAt, config?.['ttl-minutes']) ||
+        url !== metadata?.remoteConfigUrl);
+}
+function resolveConfigServicesByTag(tag, config) {
+    if ((0, pulse_utils_1.isString)(tag) && config) {
+        let services = config.scopes?.[tag]?.services || null;
+        if (!services && tag !== 'default') {
+            services = config.scopes.default.services;
+        }
+        return services;
+    }
+    return null;
+}
+let onGoingSync = null;
+// biome-ignore lint/style/useDefaultParameterLast: -
+async function syncRemoteConfig(tag = 'default', url) {
+    try {
+        if (!inMemoryConfig) {
+            inMemoryConfig = readConfigFromStorage();
+        }
+        if (!inMemoryConfig || shouldSyncRemoteConfig(url, inMemoryConfig.config, inMemoryConfig.metadata)) {
+            let remoteConfig;
+            if (onGoingSync) {
+                remoteConfig = await onGoingSync;
+            }
+            else {
+                onGoingSync = fetchRemoteConfigWithRetry(url);
+                remoteConfig = await onGoingSync;
+                onGoingSync = null;
+            }
+            inMemoryConfig = writeConfigToStorage(remoteConfig, url);
+        }
+        return resolveConfigServicesByTag(tag, inMemoryConfig?.config);
+    }
+    catch (err) {
+        loglevel_1.default.debug(err);
+        onGoingSync = null;
+        return null;
+    }
+}

package/dist/cjs/tracker-proxy/consts.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TPAAS_ALLOWED_METHODS = exports.ALLOWED_METHODS = exports.MESSAGE_TYPE_RETURN_ERROR = exports.MESSAGE_TYPE_RETURN = exports.MESSAGE_TYPE_INVOKE = exports.MESSAGE_TYPE_ACK = exports.MESSAGE_TYPE_REQUEST = exports.MESSAGE_PREFIX = void 0;
+exports.isPulseProxyMessage = isPulseProxyMessage;
+// Sync the content between files below this line:
+exports.MESSAGE_PREFIX = 'pulse-tracker-proxy';
+exports.MESSAGE_TYPE_REQUEST = `${exports.MESSAGE_PREFIX}:request`;
+exports.MESSAGE_TYPE_ACK = `${exports.MESSAGE_PREFIX}:ack`;
+exports.MESSAGE_TYPE_INVOKE = `${exports.MESSAGE_PREFIX}:invoke`;
+exports.MESSAGE_TYPE_RETURN = `${exports.MESSAGE_PREFIX}:return`;
+exports.MESSAGE_TYPE_RETURN_ERROR = `${exports.MESSAGE_PREFIX}:return-error`;
+exports.ALLOWED_METHODS = ['track'];
+exports.TPAAS_ALLOWED_METHODS = [
+    'trackAnonymousViewUIElement',
+    'trackEngagementAudio',
+    'trackEngagementForm',
+    'trackEngagementHealthUIElement',
+    'trackEngagementOffer',
+    'trackEngagementTeaser',
+    'trackEngagementUIElement',
+    'trackEngagementVideo',
+    'trackEngagementVideoAd',
+    'trackEngagementWidget',
+    'trackCompletedHealthAction',
+    'trackImpressionAdSlot',
+    'trackImpressionForm',
+    'trackImpressionHealthUIElement',
+    'trackImpressionOffer',
+    'trackImpressionPlayer',
+    'trackImpressionTeaser',
+    'trackImpressionUIElement',
+    'trackImpressionWidget',
+    'trackLeaveArticle',
+    'trackLeaveAudioPage',
+    'trackLeaveError',
+    'trackLeaveFrontpage',
+    'trackLeaveLandingpage',
+    'trackLeaveListing',
+    'trackLeaveLockedArticle',
+    'trackLeaveLockedAudio',
+    'trackLeaveLockedAudioPage',
+    'trackLeaveLockedVideo',
+    'trackLeaveLockedVideoPage',
+    'trackLeavePage',
+    'trackLeaveVideoPage',
+    'trackLeaveWeather',
+    'trackViewArticle',
+    'trackViewAudio',
+    'trackViewAudioPage',
+    'trackViewError',
+    'trackViewFrontpage',
+    'trackViewHealthPage',
+    'trackViewLandingpage',
+    'trackViewListing',
+    'trackViewLockedArticle',
+    'trackViewLockedAudio',
+    'trackViewLockedAudioPage',
+    'trackViewLockedVideo',
+    'trackViewLockedVideoPage',
+    'trackViewPage',
+    'trackViewTitle',
+    'trackViewVideo',
+    'trackViewVideoPage',
+    'trackViewWeather',
+];
+function isPulseProxyMessage(message) {
+    return (message !== null &&
+        typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        message.type.startsWith(exports.MESSAGE_PREFIX));
+}

package/dist/cjs/tracker-proxy/proxy-provider.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProxyProviderListener = startProxyProviderListener;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const loglevel_1 = __importDefault(require("loglevel"));
+const consts_1 = require("./consts");
+const ALLOWED_METHODS_SET = new Set([...consts_1.ALLOWED_METHODS, ...consts_1.TPAAS_ALLOWED_METHODS]);
+function startProxyProviderListener(tracker) {
+    if (!pulse_utils_1.isBrowser) {
+        loglevel_1.default.debug('Proxy Provider - Not in browser environment, skipping message listener');
+        return () => { };
+    }
+    loglevel_1.default.debug('Proxy Provider - Added message listener for proxy provider');
+    const listener = async (event) => {
+        loglevel_1.default.debug('Proxy Provider - message received', event.data);
+        if (!event.ports.length || !(0, consts_1.isPulseProxyMessage)(event.data)) {
+            loglevel_1.default.debug('Proxy Provider - message is not for us, skipping. Data:', event.data, 'Ports:', event.ports);
+            return;
+        }
+        const respond = (message) => {
+            loglevel_1.default.debug(`Proxy Provider - response to (${event.origin}): `, message);
+            event.ports[0].postMessage(message);
+        };
+        if (event.data.type === consts_1.MESSAGE_TYPE_REQUEST) {
+            respond({ type: consts_1.MESSAGE_TYPE_ACK });
+        }
+        else if (event.data.type === consts_1.MESSAGE_TYPE_INVOKE) {
+            /**
+             * @privateRemarks This is where the polymorphism between .track and tpaas methods break,
+             * because args can be an array with 2 or 3 arguments, and it cannot be spread in the call
+             * when the callee interface does not spread the arguments itself.
+             * In the end, almost all the implementation would have to be forked between TrackInvocation and TpaasInvocation,
+             * and it was best to stick with am undesired casting, knowing that until this point we are
+             * satisfying both implementations.
+             * @see TrackInvocation
+             * @see TpaasInvocation
+             */
+            const { method, args } = event.data.payload;
+            try {
+                if (!ALLOWED_METHODS_SET.has(method)) {
+                    respond({
+                        type: consts_1.MESSAGE_TYPE_RETURN_ERROR,
+                        error: `Method ${method} is not allowed`,
+                    });
+                    return;
+                }
+                const result = await tracker[method](...args);
+                respond({
+                    type: consts_1.MESSAGE_TYPE_RETURN,
+                    payload: result,
+                });
+            }
+            catch (error) {
+                respond({
+                    type: consts_1.MESSAGE_TYPE_RETURN_ERROR,
+                    error: `${error}`,
+                });
+            }
+        }
+    };
+    window.addEventListener('message', listener);
+    return () => {
+        window.removeEventListener('message', listener);
+    };
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/version.json

@@ -0,0 +1 @@
+{ "SDK_VERSION": "8.0.0-alpha.18", "GIT_COMMIT": "beb7e832" }