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

package/dist/ejs/network.js

@@ -0,0 +1,12 @@
+export default 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/ejs/remoteConfig/index.js

@@ -0,0 +1,111 @@
+import { isString, webApi } from '@schibsted/pulse-utils';
+import logger from 'loglevel';
+const CIS_KEY = 'cis';
+const COLLECTOR_KEY = 'collector';
+const getRemoteConfigStorageKey = '_pulse.internal.remote.config';
+let inMemoryConfig = null;
+export async function fetchRemoteConfig(url) {
+    const response = await fetch(url, {
+        method: 'GET',
+    });
+    return response.json();
+}
+export async function fetchRemoteConfigWithRetry(url, retries = 3) {
+    try {
+        return await fetchRemoteConfig(url);
+    }
+    catch (err) {
+        if (retries > 1) {
+            return fetchRemoteConfigWithRetry(url, retries - 1);
+        }
+        throw err;
+    }
+}
+export function readConfigFromStorage() {
+    try {
+        return JSON.parse(webApi.localStorage?.getItem(getRemoteConfigStorageKey) ?? '');
+    }
+    catch (_err) {
+        return null;
+    }
+}
+function writeConfigToStorage(config, url) {
+    try {
+        const configPersistence = {
+            config,
+            metadata: {
+                remoteConfigUrl: url,
+                updatedAt: new Date().toISOString(),
+            },
+        };
+        webApi.localStorage?.setItem(getRemoteConfigStorageKey, JSON.stringify(configPersistence));
+        return configPersistence;
+    }
+    catch (_err) {
+        return null;
+    }
+}
+export function clearConfigFromStorage() {
+    try {
+        webApi.localStorage?.removeItem(getRemoteConfigStorageKey);
+        return true;
+    }
+    catch (_err) {
+        return false;
+    }
+}
+export function clearInMemoryConfig() {
+    inMemoryConfig = null;
+}
+function isConfigValid(config) {
+    const isConfigValid = !!config;
+    logger.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();
+    logger.debug(`RemoteConfig: isConfigExpired: ${isConfigExpired}`);
+    return isConfigExpired;
+}
+export function shouldSyncRemoteConfig(url, config, metadata) {
+    return (!isConfigValid(config) ||
+        isConfigExpired(metadata?.updatedAt, config?.['ttl-minutes']) ||
+        url !== metadata?.remoteConfigUrl);
+}
+export function resolveConfigServicesByTag(tag, config) {
+    if (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: -
+export 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) {
+        logger.debug(err);
+        onGoingSync = null;
+        return null;
+    }
+}

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

@@ -0,0 +1,68 @@
+// Sync the content between files below this line:
+export const MESSAGE_PREFIX = 'pulse-tracker-proxy';
+export const MESSAGE_TYPE_REQUEST = `${MESSAGE_PREFIX}:request`;
+export const MESSAGE_TYPE_ACK = `${MESSAGE_PREFIX}:ack`;
+export const MESSAGE_TYPE_INVOKE = `${MESSAGE_PREFIX}:invoke`;
+export const MESSAGE_TYPE_RETURN = `${MESSAGE_PREFIX}:return`;
+export const MESSAGE_TYPE_RETURN_ERROR = `${MESSAGE_PREFIX}:return-error`;
+export const ALLOWED_METHODS = ['track'];
+export const 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',
+];
+export function isPulseProxyMessage(message) {
+    return (message !== null &&
+        typeof message === 'object' &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        message.type.startsWith(MESSAGE_PREFIX));
+}

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

@@ -0,0 +1,62 @@
+import { isBrowser } from '@schibsted/pulse-utils';
+import logger from 'loglevel';
+import { ALLOWED_METHODS, isPulseProxyMessage, MESSAGE_TYPE_ACK, MESSAGE_TYPE_INVOKE, MESSAGE_TYPE_REQUEST, MESSAGE_TYPE_RETURN, MESSAGE_TYPE_RETURN_ERROR, TPAAS_ALLOWED_METHODS, } from './consts';
+const ALLOWED_METHODS_SET = new Set([...ALLOWED_METHODS, ...TPAAS_ALLOWED_METHODS]);
+export function startProxyProviderListener(tracker) {
+    if (!isBrowser) {
+        logger.debug('Proxy Provider - Not in browser environment, skipping message listener');
+        return () => { };
+    }
+    logger.debug('Proxy Provider - Added message listener for proxy provider');
+    const listener = async (event) => {
+        logger.debug('Proxy Provider - message received', event.data);
+        if (!event.ports.length || !isPulseProxyMessage(event.data)) {
+            logger.debug('Proxy Provider - message is not for us, skipping. Data:', event.data, 'Ports:', event.ports);
+            return;
+        }
+        const respond = (message) => {
+            logger.debug(`Proxy Provider - response to (${event.origin}): `, message);
+            event.ports[0].postMessage(message);
+        };
+        if (event.data.type === MESSAGE_TYPE_REQUEST) {
+            respond({ type: MESSAGE_TYPE_ACK });
+        }
+        else if (event.data.type === 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: MESSAGE_TYPE_RETURN_ERROR,
+                        error: `Method ${method} is not allowed`,
+                    });
+                    return;
+                }
+                const result = await tracker[method](...args);
+                respond({
+                    type: MESSAGE_TYPE_RETURN,
+                    payload: result,
+                });
+            }
+            catch (error) {
+                respond({
+                    type: MESSAGE_TYPE_RETURN_ERROR,
+                    error: `${error}`,
+                });
+            }
+        }
+    };
+    window.addEventListener('message', listener);
+    return () => {
+        window.removeEventListener('message', listener);
+    };
+}

package/dist/ejs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/version.json

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

package/dist/ejs/visibility-observer/index.js

@@ -0,0 +1,97 @@
+/**
+ * Observes visibility of elements matching a selector using MutationObserver and IntersectionObserver.
+ */
+export class VisibilityObserver {
+    /**
+     * @param callback The callback function to be executed when an element becomes visible.
+     */
+    constructor(callback) {
+        this.callback = callback;
+    }
+    /**
+     * Tracks visibility of elements matching {@link selector}, triggering {@link callback} when an element is over 2/3 visible.
+     * Uses {@link https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver | MutationObserver} to monitor the DOM for dynamically loaded content.
+     * Callback is invoked only once per element.
+     * @param selector The CSS selector for elements to track.
+     * @throws Error if called more than once.
+     */
+    observe(selector) {
+        if (this.selector) {
+            throw new Error(`Cannot observe selector ${selector}. A visibility observer has already been set up for selector ${this.selector}.`);
+        }
+        this.selector = selector;
+        this.setupObservers();
+        // biome-ignore lint/suspicious/useIterableCallbackReturn: -
+        this.elements().forEach((elementToTrack) => this.observeIntersection(elementToTrack));
+    }
+    /**
+     * @returns {HTMLElement[]} An array of elements that match the selector in the document.
+     */
+    elements() {
+        return Array.from(document.querySelectorAll(this.selector));
+    }
+    // Initialize both observers and start watching for DOM changes
+    setupObservers() {
+        this.setupIntersectionObserver();
+        this.setupMutationObserver();
+        this.observeMutations();
+    }
+    // Create observer to detect when elements become visible in the viewport
+    setupIntersectionObserver() {
+        this.intersectionObserver = new IntersectionObserver((entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting) {
+                    const node = entry.target;
+                    this.callback(node);
+                    this.intersectionObserver.unobserve(node);
+                }
+            });
+        }, { threshold: 2 / 3 });
+    }
+    // Create observer to detect DOM changes that may add/remove tracked elements
+    setupMutationObserver() {
+        this.mutationObserver = new MutationObserver((mutations) => {
+            mutations.forEach((mutation) => {
+                this.handleAddedNodes(mutation.addedNodes);
+                this.handleRemovedNodes(mutation.removedNodes);
+            });
+        });
+    }
+    handleAddedNodes(nodes) {
+        this.processHtmlNodes(nodes, (element) => this.observeIntersection(element));
+    }
+    handleRemovedNodes(nodes) {
+        this.processHtmlNodes(nodes, (element) => this.intersectionObserver.unobserve(element));
+    }
+    processHtmlNodes(nodes, action) {
+        nodes.forEach((node) => {
+            if (node instanceof HTMLElement && this.nodeMatchesOrContainsSelector(node)) {
+                this.processMatchingElements(node, action);
+            }
+        });
+    }
+    processMatchingElements(node, action) {
+        const elementsToTrack = this.extractElementsToTrack(node);
+        elementsToTrack.forEach(action);
+    }
+    nodeMatchesOrContainsSelector(node) {
+        return node.matches(this.selector) || node.querySelector(this.selector) !== null;
+    }
+    // Get matching descendants and the node itself if it matches the selector
+    extractElementsToTrack(node) {
+        const elements = Array.from(node.querySelectorAll(this.selector));
+        if (node.matches(this.selector)) {
+            elements.push(node);
+        }
+        return elements;
+    }
+    observeIntersection(node) {
+        this.intersectionObserver.observe(node);
+    }
+    observeMutations() {
+        this.mutationObserver.observe(document.body, {
+            childList: true,
+            subtree: true,
+        });
+    }
+}

package/dist/ejs/warnOnce.js

@@ -0,0 +1,9 @@
+const warned = {};
+const warnOnce = (id, ...data) => {
+    if (warned[id]) {
+        return;
+    }
+    warned[id] = true;
+    console.warn(...data);
+};
+export default warnOnce;

package/dist/ejs/wrapper/engagement/ui-element/event-builder.js

@@ -0,0 +1,17 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildClickUIElementEvent = (inputProperties, currentPage) => ({
+    ...inputProperties,
+    type: 'Engagement',
+    action: 'Click',
+    object: Promise.resolve(currentPage).then((page) => ({
+        page,
+        ...inputProperties.object,
+        navigationType: getNavigationType(),
+        type: 'UIElement',
+        url: window.location.href,
+    })),
+    ...(inputProperties.metrics && { metrics: inputProperties.metrics }),
+    ...(inputProperties.experiments && {
+        experiments: inputProperties.experiments,
+    }),
+});

package/dist/ejs/wrapper/engagement/ui-element/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/types/base-event.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/types/engagement-event.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/types/event.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/types/index.js

@@ -0,0 +1,3 @@
+export * from './base-event.js';
+export * from './event.js';
+export * from './utils.js';

package/dist/ejs/wrapper/types/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/utils/get-navigation-type.js

@@ -0,0 +1,29 @@
+// implementation "copy-pasted" from the wrapper
+const modernNavigationMap = {
+    navigate: 'navigation',
+    reload: 'refresh',
+};
+const legacyNavigationMap = {
+    0: 'navigation',
+    1: 'refresh',
+};
+const getModernNavigationType = (entryType) => {
+    return modernNavigationMap[entryType] || 'alternative';
+};
+const getLegacyNavigationType = (entryType) => {
+    return legacyNavigationMap[entryType] || 'alternative';
+};
+const getNavigationType = () => {
+    if (typeof window === 'undefined' || typeof window.performance === 'undefined') {
+        return 'unknown';
+    }
+    const [navigationEntry] = window.performance.getEntriesByType('navigation');
+    if (navigationEntry) {
+        return getModernNavigationType(navigationEntry.type);
+    }
+    if (performance.navigation?.type !== undefined) {
+        return getLegacyNavigationType(performance.navigation.type);
+    }
+    return 'unknown';
+};
+export { getNavigationType };

package/dist/ejs/wrapper/utils/page-from-page-view.js

@@ -0,0 +1,6 @@
+const pageFromPageView = (pageView) => Promise.resolve(pageView.object).then((objectProperties) => ({
+    id: objectProperties.id,
+    type: (objectProperties.type || 'Page'),
+    url: objectProperties.url || window.location.href,
+}));
+export { pageFromPageView };

package/dist/ejs/wrapper/view/article/event-builder.js

@@ -0,0 +1,15 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildLegacyViewArticleEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => {
+        const { articleId, ...rest } = objectProperties;
+        return {
+            ...rest,
+            id: articleId,
+            navigationType: getNavigationType(),
+            type: 'Article',
+            contentId: articleId,
+            url: window.location.href,
+        };
+    }),
+});

package/dist/ejs/wrapper/view/article/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/frontpage/event-builder.js

@@ -0,0 +1,12 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildLegacyViewFrontpageEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => {
+        return {
+            ...objectProperties,
+            navigationType: getNavigationType(),
+            type: 'Frontpage',
+            url: window.location.href,
+        };
+    }),
+});

package/dist/ejs/wrapper/view/frontpage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/listing/event-builder.js

@@ -0,0 +1,10 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildLegacyViewListingEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => ({
+        ...objectProperties,
+        navigationType: getNavigationType(),
+        type: 'Listing',
+        url: window.location.href,
+    })),
+});

package/dist/ejs/wrapper/view/listing/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/loginposter/event-builder.js

@@ -0,0 +1,7 @@
+export const buildViewLoginPosterEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => ({
+        ...objectProperties,
+        type: 'LoginPoster',
+    })),
+});

package/dist/ejs/wrapper/view/loginposter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/page/event-builder.js

@@ -0,0 +1,14 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildLegacyViewPageEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => {
+        const { pageId, ...rest } = objectProperties;
+        return {
+            ...rest,
+            id: pageId,
+            navigationType: getNavigationType(),
+            type: 'Page',
+            url: window.location.href,
+        };
+    }),
+});

package/dist/ejs/wrapper/view/page/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/salesposter/event-builder.js

@@ -0,0 +1,14 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildViewSalesPosterEvent = (inputProperties) => ({
+    ...inputProperties,
+    object: Promise.resolve(inputProperties.object).then((objectProperties) => {
+        const { articleId, ...rest } = objectProperties;
+        return {
+            ...rest,
+            id: articleId,
+            navigationType: getNavigationType(),
+            type: 'SalesPoster',
+            url: window.location.href,
+        };
+    }),
+});

package/dist/ejs/wrapper/view/salesposter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ejs/wrapper/view/ui-element/event-builder.js

@@ -0,0 +1,11 @@
+import { getNavigationType } from '../../utils/get-navigation-type.js';
+export const buildLegacyViewUIElementEvent = (inputProperties, currentPage) => ({
+    ...inputProperties,
+    object: Promise.all([inputProperties.object, currentPage]).then(([objectProperties, page]) => ({
+        page,
+        ...objectProperties,
+        navigationType: getNavigationType(),
+        type: 'UIElement',
+        url: window.location.href,
+    })),
+});

package/dist/ejs/wrapper/view/ui-element/types.js

@@ -0,0 +1 @@
+export {};