@schibsted/pulse-sdk 8.0.0-rc.20 → 8.0.0-rc.21

package/dist/ejs/builders/session-browser.js

@@ -1,75 +1,5 @@
-import { v4 as uuid } from 'uuid';
-import { cookieConfig, getRootDomain, getXDomainId, isBrowser, readCookie, writeCookie } from '../utils';
-const { USE_LOCALSTORAGE } = cookieConfig;
-const SESSION_STORAGE_KEY = '_pulsesession';
-const generateSessionSDRN = (sessionId) => `sdrn:schibsted:session:${sessionId}`;
-// Return parsed json from cookie (or localStorage if enabled), or undefined.
-export const readAndParse = (storageKey) => {
-    try {
-        const storedSession = readCookie(storageKey);
-        if (storedSession) {
-            return JSON.parse(storedSession);
-        }
-    }
-    catch (_e) {
-        // If localStorage/cookie is not available, we treat it as if
-        // the value is undefined.
-        // If data is unparseable, we also ignore it.
-        return undefined;
-    }
-    return undefined;
-};
-// Read and parse session data from localStorage.
-// Any invalid or unreadable data is ignored.
-export const readSession = () => {
-    const storedSession = readAndParse(SESSION_STORAGE_KEY);
-    if (storedSession) {
-        const [id, startTimeMs, lastEventTimeMs] = storedSession;
-        const startTime = new Date(startTimeMs);
-        const lastEventTime = new Date(lastEventTimeMs);
-        if (id &&
-            startTime &&
-            lastEventTime &&
-            !Number.isNaN(startTime.getTime()) &&
-            !Number.isNaN(lastEventTime.getTime())) {
-            return { id, startTime, lastEventTime };
-        }
-    }
-    return undefined;
-};
-// Write session data to localStorage
-const writeSession = (session) => {
-    const { id, startTime, lastEventTime } = session;
-    try {
-        const sessionToStore = [id, startTime.getTime(), lastEventTime.getTime()];
-        const halfHourInDays = 1.0 / (24 * 2);
-        writeCookie(SESSION_STORAGE_KEY, JSON.stringify(sessionToStore), getRootDomain(), halfHourInDays);
-        // Delete old localStorage-based session if needed
-        if (!USE_LOCALSTORAGE && isBrowser && window.localStorage) {
-            // removeItem will do nothing to a non-existing item.
-            window.localStorage.removeItem(SESSION_STORAGE_KEY);
-        }
-    }
-    catch (_e) {
-        // If we can't write the session, we just move on in life
-    }
-};
-const createSession = (eventCreationDate) => {
-    const now = eventCreationDate ?? new Date();
-    return {
-        id: generateSessionSDRN(uuid()),
-        startTime: now,
-        lastEventTime: now,
-    };
-};
-const updateSession = (session, eventCreationDate) => {
-    const now = eventCreationDate ?? new Date();
-    const sessionMaxInterval = 30 * 60 * 1000; // 30 minutes in milliseconds
-    if (!session || session.lastEventTime.getTime() < now.getTime() - sessionMaxInterval) {
-        return createSession(now);
-    }
-    return { ...session, lastEventTime: now };
-};
+import { generateSessionSDRN, touchSession } from '../session/store';
+import { getXDomainId } from '../utils';
 export const defaultValue = () => undefined;
 // Add session information to an event
 // {
@@ -79,12 +9,9 @@ export const defaultValue = () => undefined;
 //   }
 // }
 export default function session(_input, eventCreationDate) {
-    const oldSession = readSession();
-    const newSession = updateSession(oldSession, eventCreationDate);
-    writeSession(newSession);
-    const { id, startTime } = newSession;
+    const { sessionId, startTime } = touchSession(eventCreationDate ?? new Date());
     return {
-        '@id': id,
+        '@id': generateSessionSDRN(sessionId),
         startTime: startTime.toISOString(),
         xDomainId: getXDomainId(),
     };

package/dist/ejs/session/store.js

@@ -0,0 +1,90 @@
+import { v4 as uuid } from 'uuid';
+import { cookieConfig, getRootDomain, readCookie, SESSION_SDRN_PREFIX, webApi, writeCookie } from '../utils';
+const { USE_LOCALSTORAGE } = cookieConfig;
+const SESSION_STORAGE_KEY = '_pulsesession';
+const SESSION_MAX_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * @private
+ */
+export const generateSessionSDRN = (sessionId) => `${SESSION_SDRN_PREFIX}${sessionId}`;
+// Return parsed json from cookie (or localStorage if enabled), or undefined.
+const readAndParse = () => {
+    try {
+        const storedSession = readCookie(SESSION_STORAGE_KEY);
+        if (storedSession) {
+            return JSON.parse(storedSession);
+        }
+    }
+    catch (_e) {
+        // If localStorage/cookie is not available, we treat it as if
+        // the value is undefined.
+        // If data is unparseable, we also ignore it.
+        return undefined;
+    }
+    return undefined;
+};
+/**
+ * Reads the stored session. Any invalid or unreadable data is ignored.
+ * @private
+ */
+export const readSession = () => {
+    const storedSession = readAndParse();
+    if (storedSession) {
+        const [sessionSdrn, startTimeMs, lastEventTimeMs] = storedSession;
+        const startTime = new Date(startTimeMs);
+        const lastEventTime = new Date(lastEventTimeMs);
+        if (sessionSdrn && !Number.isNaN(startTime.getTime()) && !Number.isNaN(lastEventTime.getTime())) {
+            return {
+                // the session is stored as an SDRN, for compatibility with legacy events and older SDK versions
+                sessionId: sessionSdrn.replace(SESSION_SDRN_PREFIX, ''),
+                startTime,
+                lastEventTime,
+            };
+        }
+    }
+    return undefined;
+};
+const writeSession = ({ sessionId, startTime, lastEventTime }) => {
+    try {
+        // SDK v8 (supporting TPaaS events) needs to be compatible with legacy events AND older SDK versions
+        // as a result, we can't store just the sessionId, we need the full SDRN in there
+        const sessionToStore = [
+            generateSessionSDRN(sessionId),
+            startTime.getTime(),
+            lastEventTime.getTime(),
+        ];
+        const halfHourInDays = 1.0 / (24 * 2);
+        writeCookie(SESSION_STORAGE_KEY, JSON.stringify(sessionToStore), getRootDomain(), halfHourInDays);
+        // Delete old localStorage-based session if needed
+        if (!USE_LOCALSTORAGE) {
+            // removeItem will do nothing to a non-existing item.
+            webApi.localStorage?.removeItem(SESSION_STORAGE_KEY);
+        }
+    }
+    catch (_e) {
+        // If we can't write the session, we just move on in life
+    }
+};
+const updateSession = (createdAt, session) => {
+    if (!session || session.lastEventTime.getTime() < createdAt.getTime() - SESSION_MAX_INTERVAL_MS) {
+        return { sessionId: uuid(), startTime: createdAt, lastEventTime: createdAt, isFirstEvent: true };
+    }
+    // Never move lastEventTime backwards, or the session would expire early.
+    // In case the order of events is not strictly chronological, this ensures the session remains valid.
+    const lastEventTime = createdAt.getTime() > session.lastEventTime.getTime() ? createdAt : session.lastEventTime;
+    return { ...session, lastEventTime, isFirstEvent: false };
+};
+/**
+ * Registers an event created at `createdAt` in the stored session: extends the current session,
+ * or starts a new one when it expired, and stores the result.
+ *
+ * Call it synchronously, together with capturing `createdAt`, before any asynchronous work,
+ * so sessions are updated in the order events are tracked.
+ *
+ * @private
+ */
+export const touchSession = (createdAt) => {
+    const session = updateSession(createdAt, readSession());
+    writeSession(session);
+    return session;
+};

package/dist/ejs/tpaas-builders/builders/device.js

@@ -1,16 +1,14 @@
 import * as logger from 'loglevel';
 import { UAParser } from 'ua-parser-js';
-import { isBrowser } from '../../utils';
-// Cache the UAParser result to avoid re-parsing on subsequent calls
-let cachedUAParser;
-function getUAParser() {
-    if (!cachedUAParser) {
-        cachedUAParser = UAParser();
-    }
-    return cachedUAParser;
+let cachedUserAgentResult;
+function getUserAgentResult(userAgent) {
+    if (cachedUserAgentResult?.ua !== userAgent) {
+        cachedUserAgentResult = UAParser(userAgent);
+    }
+    return cachedUserAgentResult;
 }
-export const builder = (environmentId, jwe) => {
-    if (!isBrowser) {
+export const builder = (environmentId, jwe, browser) => {
+    if (browser.userAgent === undefined) {
         return {
             device: {
                 // TODO: server side rendering (or nodejs). do we need to set all the following fields?
@@ -25,7 +23,7 @@ export const builder = (environmentId, jwe) => {
             },
         };
     }
-    const uaParser = getUAParser();
+    const uaParser = getUserAgentResult(browser.userAgent);
     return {
         device: {
             clientType: getClientType(uaParser),
@@ -36,12 +34,42 @@ export const builder = (environmentId, jwe) => {
             mobileBrand: uaParser.device.vendor,
             mobileModel: uaParser.device.model,
             operatingSystem: getOperatingSystem(uaParser),
-            screenOrientation: getScreenOrientation(),
-            userAgent: window.navigator.userAgent,
-            viewportSize: getViewportSize(),
+            screenOrientation: getScreenOrientation(browser.screenOrientationType),
+            userAgent: browser.userAgent,
+            viewportSize: getViewportSize(browser.viewportWidth, browser.viewportHeight),
         },
     };
 };
+function getScreenOrientation(orientationType) {
+    if (orientationType === 'landscape-primary' || orientationType === 'landscape-secondary') {
+        return 'Landscape';
+    }
+    return 'Portrait';
+}
+function getSizeFromPixels(pixels) {
+    if (pixels < 360) {
+        return 'XS';
+    }
+    if (pixels < 480) {
+        return 'S';
+    }
+    if (pixels < 768) {
+        return 'M';
+    }
+    if (pixels < 1024) {
+        return 'L';
+    }
+    if (pixels >= 1024) {
+        return 'XL';
+    }
+    logger.error('Could not determine viewport size, defaulting to M');
+    return 'M';
+}
+function getViewportSize(viewportWidth, viewportHeight) {
+    const size = getSizeFromPixels(Math.min(viewportWidth, viewportHeight));
+    logger.debug(`Viewport size: ${viewportWidth}x${viewportHeight}, mapped to ${size}`);
+    return size;
+}
 function getClientType(uaParser) {
     const { browser } = uaParser;
     const browserName = browser.name?.toLocaleLowerCase() || '';
@@ -122,59 +150,3 @@ function getOperatingSystem(uaParser) {
     // default value
     return 'Other';
 }
-function getScreenOrientation() {
-    const orientationType = window.screen.orientation?.type;
-    const portraitOrientations = ['portrait-primary', 'portrait-secondary'];
-    const landscapeOrientations = ['landscape-primary', 'landscape-secondary'];
-    // the ifs might be a bit overkill, but it helps with separating the default value from the logic
-    if (portraitOrientations.includes(orientationType)) {
-        return 'Portrait';
-    }
-    if (landscapeOrientations.includes(orientationType)) {
-        return 'Landscape';
-    }
-    // default value
-    return 'Portrait';
-}
-function getSizeFromPixels(pixels) {
-    if (pixels < 360) {
-        return 'XS';
-    }
-    if (pixels < 480) {
-        return 'S';
-    }
-    if (pixels < 768) {
-        return 'M';
-    }
-    if (pixels < 1024) {
-        return 'L';
-    }
-    if (pixels >= 1024) {
-        return 'XL';
-    }
-    // default value
-    logger.error('Could not determine viewport size, defaulting to M');
-    return 'M';
-}
-function getViewportSize() {
-    let viewportWidth;
-    let viewportHeight;
-    const { document } = window;
-    if (typeof window.innerWidth !== 'undefined') {
-        viewportWidth = window.innerWidth;
-        viewportHeight = window.innerHeight;
-    }
-    else if (typeof document.documentElement.clientWidth !== 'undefined' &&
-        document.documentElement.clientWidth !== 0) {
-        viewportWidth = document.documentElement.clientWidth;
-        viewportHeight = document.documentElement.clientHeight;
-    }
-    else {
-        viewportWidth = document.getElementsByTagName('body')[0].clientWidth;
-        viewportHeight = document.getElementsByTagName('body')[0].clientHeight;
-    }
-    const shortestDimension = Math.min(viewportWidth, viewportHeight);
-    const size = getSizeFromPixels(shortestDimension);
-    logger.debug(`Viewport size: ${viewportWidth}x${viewportHeight}, mapped to ${size}`);
-    return size;
-}

package/dist/ejs/tpaas-builders/builders/pageInfo.js

@@ -1,5 +1,4 @@
-import { isBrowser } from '../../utils';
-export const builder = (currentPage) => {
+export const builder = (currentPage, url) => {
     // if something happens and there was no View Page type of event sent before, we need a fallback
     if (!currentPage) {
         return {
@@ -7,7 +6,7 @@ export const builder = (currentPage) => {
                 info: {
                     pageId: 'unknown',
                     pageType: 'Page',
-                    url: isBrowser ? window.location.href : undefined,
+                    url,
                 },
             },
         };

package/dist/ejs/tpaas-builders/builders/session.js

@@ -1,111 +1 @@
-import { v4 as uuid } from 'uuid';
-import { cookieConfig, getRootDomain, getXDomainId, readCookie, SESSION_SDRN_PREFIX, webApi, writeCookie, } from '../../utils';
-const { USE_LOCALSTORAGE } = cookieConfig;
-const SESSION_STORAGE_KEY = '_pulsesession';
-const generateSessionSDRN = (sessionId) => `${SESSION_SDRN_PREFIX}${sessionId}`;
-// 1. there are pros and cons to outputting { session: ISession } instead of just ISession
-// this allows us to always have the session builde populate the same property (in this case '.session')
-// if in the future we want the session builder to populate other properties, we should just output ISession and move the mapping logic in index.ts, as part of buildersByEventType
-// 2. we don't need builder-level "isBrowser" checks. If an event is not supposed to be fired from the browser, then the builder shouldn't be assigned to it in buildersByEventType in index.ts
-// however, we should keep minimal "isBrowser" checks before webApi calls because the code might run in SSR environments
-export const builder = (createdAt) => {
-    const oldSession = readSession();
-    const newSession = updateSession(createdAt, oldSession);
-    writeSession(newSession);
-    const { sessionId, startTime, isFirstEvent } = newSession;
-    return {
-        session: {
-            isFirstEvent,
-            sessionId,
-            startTime,
-            xDomainId: getXDomainId(),
-        },
-    };
-};
-// Return parsed json from cookie (or localStorage if enabled), or undefined.
-// exported for testing purposes.
-export const readAndParse = (storageKey) => {
-    try {
-        const storedSession = readCookie(storageKey);
-        if (storedSession) {
-            return JSON.parse(storedSession);
-        }
-    }
-    catch (_e) {
-        // If localStorage/cookie is not available, we treat it as if
-        // the value is undefined.
-        // If data is unparseable, we also ignore it.
-        return undefined;
-    }
-    return undefined;
-};
-// Read and parse session data from localStorage.
-// Any invalid or unreadable data is ignored.
-export const readSession = () => {
-    const storedSession = readAndParse(SESSION_STORAGE_KEY);
-    if (storedSession) {
-        const [sessionId, startTimeMs, lastEventTimeMs] = storedSession;
-        const startTime = new Date(startTimeMs);
-        const lastEventTime = new Date(lastEventTimeMs);
-        if (sessionId &&
-            startTime &&
-            lastEventTime &&
-            !Number.isNaN(startTime.getTime()) &&
-            !Number.isNaN(lastEventTime.getTime())) {
-            return {
-                // to ensure backwards compatibility between the new TPaaS sessionId format and old sessions
-                // we need to remove the SDRN prefix from old sessionIds before using it
-                sessionId: sessionId.replace(SESSION_SDRN_PREFIX, ''),
-                startTime: startTime.toISOString(),
-                lastEventTime,
-                isFirstEvent: false,
-            };
-        }
-    }
-    return undefined;
-};
-// Write session data to localStorage
-const writeSession = (session) => {
-    const { sessionId, startTime, lastEventTime } = session;
-    // SDK v8 (supporting TPaaS events) needs to be compatible with legacy events AND older SDK versions
-    // as a result, we can't store just the sessionId, we need the full SDRN in there
-    const sessionSdrn = generateSessionSDRN(sessionId);
-    try {
-        const sessionToStore = [
-            sessionSdrn,
-            new Date(startTime).getTime(),
-            lastEventTime.getTime(),
-        ];
-        const halfHourInDays = 1.0 / (24 * 2);
-        writeCookie(SESSION_STORAGE_KEY, JSON.stringify(sessionToStore), getRootDomain(), halfHourInDays);
-        // Delete old localStorage-based session if needed
-        if (!USE_LOCALSTORAGE) {
-            // removeItem will do nothing to a non-existing item.
-            // use webApi.localStorage instead of window.localStorage
-            webApi.localStorage?.removeItem(SESSION_STORAGE_KEY);
-        }
-    }
-    catch (_e) {
-        // If we can't write the session, we just move on in life
-    }
-};
-const createSession = (eventCreationDate) => {
-    const now = eventCreationDate ?? new Date();
-    return {
-        sessionId: uuid(),
-        startTime: now.toISOString(),
-        lastEventTime: now,
-        isFirstEvent: true,
-    };
-};
-const updateSession = (eventCreationDate, session) => {
-    const sessionMaxInterval = 30 * 60 * 1000; // 30 minutes in milliseconds
-    if (!session || session.lastEventTime.getTime() < eventCreationDate.getTime() - sessionMaxInterval) {
-        return createSession(eventCreationDate);
-    }
-    return {
-        ...session,
-        isFirstEvent: false,
-        lastEventTime: eventCreationDate,
-    };
-};
+export const builder = (session) => ({ session });

package/dist/ejs/tpaas-builders/builders/utm.js

@@ -1,12 +1,6 @@
 import { UTM_MEDIUM_VALUES } from '../../tpaas-schemas';
-import { isBrowser } from '../../utils';
-export const builder = () => {
-    if (!isBrowser) {
-        return {
-            page: {},
-        };
-    }
-    const urlParams = new URLSearchParams(window?.location?.search ?? '');
+export const builder = (search) => {
+    const urlParams = new URLSearchParams(search);
     const utmCampaign = urlParams.get('utm_campaign');
     const utmContent = urlParams.get('utm_content');
     const utmMediumRaw = urlParams.get('utm_medium');