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

package/node_modules/@schibsted/pulse-utils/dist/types/get.d.ts

@@ -0,0 +1 @@
+export declare function get(object: any, path: string, defaultValue: any): any;

package/node_modules/@schibsted/pulse-utils/dist/types/getRootDomain.d.ts

@@ -0,0 +1,13 @@
+export declare function makeGetRootDomainCached(): () => string;
+export declare const resetGetRootDomain: () => void;
+/**
+ * Function for getting the highest cookie domain where a cookie can be placed.
+ * This is done by trying to set and then read back a cookie at the tld, and
+ * then working downwards.
+ *
+ * This function is memoized as `window.location.hostname` is supposed to be
+ * immutable during the lifetime of the code.
+ *
+ * @returns {string} the top domain for setting cookies. Example: aftonbladet.se
+ */
+export declare let getRootDomain: () => string;

package/node_modules/@schibsted/pulse-utils/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+export { deleteCookie, readCookie, writeCookie } from './cookie';
+export { cookieConfig } from './cookie-config';
+export { dateTime, deviceType, evaluateAndFlatten, evaluateEventInput } from './events';
+export { get } from './get';
+export { getRootDomain, resetGetRootDomain } from './getRootDomain';
+export { pulseMerge } from './merge';
+export { isFunction, isObject, isObjectEmpty, isPlainObject, isPromise, isString } from './objects';
+export { omit } from './omit';
+export { randomString } from './randomString';
+export { throttle } from './throttle';
+export { initializeStorage, isBrowser, type StorageType, webApi } from './webApi';

package/node_modules/@schibsted/pulse-utils/dist/types/merge.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This function deep merges objects, concatenates array and handles promises as values.
+ */
+export declare function pulseMerge(target: any, ...sources: any[]): any;

package/node_modules/@schibsted/pulse-utils/dist/types/objects.d.ts

@@ -0,0 +1,6 @@
+export declare function isObject(value?: unknown): value is Record<string, unknown>;
+export declare function isPlainObject(value?: unknown): value is Record<string, unknown>;
+export declare function isFunction(value: unknown): value is (...args: any[]) => any;
+export declare function isString(s: unknown): s is string;
+export declare function isPromise(s: unknown): s is Promise<unknown>;
+export declare function isObjectEmpty(obj: object): boolean;

package/node_modules/@schibsted/pulse-utils/dist/types/omit.d.ts

@@ -0,0 +1,3 @@
+export declare function omit(target: unknown, props: string[]): {
+    [k: string]: any;
+};

package/node_modules/@schibsted/pulse-utils/dist/types/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length?: number): string;

package/node_modules/@schibsted/pulse-utils/dist/types/throttle.d.ts

@@ -0,0 +1,3 @@
+export declare function throttle<T extends (...args: unknown[]) => void>(func: T, wait?: number): {
+    cancel: () => void;
+} & ((...args: Parameters<T>) => void);

package/node_modules/@schibsted/pulse-utils/dist/types/webApi.d.ts

@@ -0,0 +1,10 @@
+export type StorageType = 'localStorage' | 'sessionStorage';
+export declare const isBrowser: boolean;
+type WebApi = {
+    crypto: Crypto;
+    localStorage?: Storage;
+    sessionStorage?: Storage;
+};
+export declare const initializeStorage: (storageType: StorageType) => Storage | undefined;
+export declare const webApi: WebApi;
+export {};

package/node_modules/@schibsted/pulse-utils/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@schibsted/pulse-utils",
+  "version": "1.0.2",
+  "description": "Common js utils",
+  "author": "Schibsted Data&Tech",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://schibsted.ghe.com/data-platform/pulse-sdk-js.git",
+    "directory": "workspaces/sdk"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/ejs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm run build:cjs && pnpm run build:ejs && pnpm run build:types",
+    "build:clean": "rm -fr dist",
+    "build:ejs": "tsc --project tsconfig.ejs.json",
+    "build:types": "tsc --project tsconfig.types.json",
+    "build:cjs": "tsc",
+    "dev": "tsc --watch",
+    "test": "pnpm run test:lint && pnpm run test:unit",
+    "test:lint": "biome check",
+    "test:lint:fix": "biome check --write",
+    "test:unit": "vitest run"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.17.24",
+    "@types/node": "24.10.13",
+    "lodash": "4.17.23",
+    "typescript": "5.9.3"
+  }
+}

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/anonymous.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = builder;
+function builder() {
+    return {
+        isAnonymous: true,
+    };
+}

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/baseEvent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = builder;
+const uuid_1 = require("uuid");
+function builder() {
+    return {
+        eventId: (0, uuid_1.v4)(),
+    };
+}

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/consents.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = builder;
+function builder(consents) {
+    return { consents: consents || getDefaultConsents() };
+}
+function getDefaultConsents() {
+    return {
+        advertising: 'Unknown',
+        analytics: 'Unknown',
+        marketing: 'Unknown',
+        personalization: 'Unknown',
+        source: 'default',
+    };
+}

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/device.js

@@ -0,0 +1,211 @@
+"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.builder = void 0;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const logger = __importStar(require("loglevel"));
+const ua_parser_js_1 = require("ua-parser-js");
+// Cache the UAParser result to avoid re-parsing on subsequent calls
+let cachedUAParser;
+function getUAParser() {
+    if (!cachedUAParser) {
+        cachedUAParser = (0, ua_parser_js_1.UAParser)();
+    }
+    return cachedUAParser;
+}
+const builder = (environmentId, jwe) => {
+    if (!pulse_utils_1.isBrowser) {
+        return {
+            device: {
+                // TODO: server side rendering (or nodejs). do we need to set all the following fields?
+                // should the SDK get request headers in that case?
+                clientType: 'Other',
+                browserVersion: '',
+                deviceType: 'Other',
+                environmentId: '',
+                operatingSystem: 'Other',
+                screenOrientation: 'Portrait',
+                viewportSize: 'XS',
+            },
+        };
+    }
+    const uaParser = getUAParser();
+    return {
+        device: {
+            clientType: getClientType(uaParser),
+            browserVersion: uaParser.browser.version || '',
+            deviceType: getDeviceType(uaParser),
+            environmentId,
+            jweIds: jwe,
+            mobileBrand: uaParser.device.vendor,
+            mobileModel: uaParser.device.model,
+            operatingSystem: getOperatingSystem(uaParser),
+            screenOrientation: getScreenOrientation(),
+            userAgent: window.navigator.userAgent,
+            viewportSize: getViewportSize(),
+        },
+    };
+};
+exports.builder = builder;
+function getClientType(uaParser) {
+    const { browser } = uaParser;
+    const browserName = browser.name?.toLocaleLowerCase() || '';
+    if (browserName.includes('webview')) {
+        // works for Chrome and Edge webview
+        // unfortunately, Safari webview does not include "webview" in the user agent
+        // so we can't detect it reliably
+        return 'Webview';
+    }
+    if (browserName.includes('chrome')) {
+        return 'Chrome';
+    }
+    if (browserName.includes('safari')) {
+        return 'Safari';
+    }
+    if (browserName.includes('firefox')) {
+        return 'Firefox';
+    }
+    if (browserName.includes('edge')) {
+        return 'Edge';
+    }
+    if (browserName.includes('samsung')) {
+        return 'Samsung';
+    }
+    // there's one more value in IDevice.clientType, "NativeScreen", but that's for the native apps
+    logger.log(`Unknown client type: ${browserName}. Defaulting to 'other'.`);
+    return 'Other';
+}
+function getDeviceType(uaParser) {
+    const { device } = uaParser;
+    switch (device.type) {
+        case 'mobile':
+            return 'Mobile';
+        case 'tablet':
+            return 'Tablet';
+        case 'smarttv':
+            return 'SmartTv';
+        // this might look weird, but device.type is undefined for desktop/laptops
+        // ua-parser-js only returns what it can detect from UA, and desktop/laptop is not a specific type
+        // the absence of a device usually means that it's desktop/laptop
+        // see https://github.com/faisalman/ua-parser-js/issues/182
+        case undefined:
+            return 'Desktop';
+        // other device types available in ua-parser-js, but unused in TPaaS:
+        // case 'console':
+        // case 'wearable':
+        // case 'embedded':
+        default:
+            logger.log(`Unknown device type: ${device.type}. Defaulting to 'other'.`);
+            return 'Other';
+    }
+}
+// maybe grab information from navigation.userAgentData in the future
+// at the moment, userAgentData is considered experimental and is not supported in firefox and safari
+function getOperatingSystem(uaParser) {
+    const { os } = uaParser;
+    const osName = os.name?.toLocaleLowerCase() || '';
+    if (osName.includes('windows')) {
+        return 'Windows';
+    }
+    if (osName.includes('macos')) {
+        return 'Mac';
+    }
+    // some flavors of Linux might not be captured by this
+    // do we need a better detection, based on a list?
+    // for example (Gentoo - https://docs.uaparser.dev/info/os/name.html)
+    if (osName.includes('linux')) {
+        return 'Linux';
+    }
+    // the TPaaS `device` template is missing Android, iOS, iPadOS and maybe others?
+    logger.log(`Unknown operating system: ${osName}. Defaulting to 'other'.`);
+    // 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/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/experiments.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (baseExperiments = [], eventExperiments = []) => {
+    const experiments = [...baseExperiments, ...eventExperiments];
+    if (experiments.length === 0) {
+        return {};
+    }
+    return { experiments };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/navigationType.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (eventNavigationType) => {
+    if (eventNavigationType) {
+        return {
+            page: {
+                navigationType: eventNavigationType,
+            },
+        };
+    }
+    return {
+        page: {
+            navigationType: getNavigationType(),
+        },
+    };
+};
+exports.builder = builder;
+// In practice they use the same values, but for future proofing we keep them separate and mapped
+const modernNavigationMap = {
+    navigate: 'Navigate',
+    reload: 'Reload',
+    back_forward: 'BackForward',
+    prerender: 'Prerender',
+};
+const legacyNavigationMap = {
+    0: 'Navigate',
+    1: 'Reload',
+    2: 'BackForward',
+};
+const getModernNavigationType = (entryType) => {
+    return modernNavigationMap[entryType];
+};
+const getLegacyNavigationType = (entryType) => {
+    return legacyNavigationMap[entryType] || 'Navigate';
+};
+// implementation is very similar to the one in sdk/src/navigation-type that was copied from the Media Wrapper
+const getNavigationType = () => {
+    if (typeof window === 'undefined' || typeof window.performance === 'undefined') {
+        // ideally we shouldn't be in this case, but if we are, we assume a navigation happened
+        // we could also assume it's a 'prerender', but let's keep it simple for now
+        return 'Navigate';
+    }
+    const [navigationEntry] = window.performance.getEntriesByType('navigation');
+    if (navigationEntry) {
+        return getModernNavigationType(navigationEntry.type);
+    }
+    if (performance.navigation?.type !== undefined) {
+        return getLegacyNavigationType(performance.navigation.type);
+    }
+    return 'Navigate';
+};

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/pageInfo.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const builder = (currentPage) => {
+    // if something happens and there was no View Page type of event sent before, we need a fallback
+    if (!currentPage) {
+        return {
+            page: {
+                info: {
+                    pageId: 'unknown',
+                    pageType: 'Page',
+                    url: pulse_utils_1.isBrowser ? window.location.href : undefined,
+                },
+            },
+        };
+    }
+    return {
+        page: {
+            info: currentPage,
+        },
+    };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/pageviewId.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (pageviewId) => {
+    return {
+        page: {
+            pageviewId,
+        },
+    };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/provider.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = builder;
+const generateProviderSDRN = (providerId) => `sdrn:schibsted:client:${providerId}`;
+function builder(providerId) {
+    return {
+        provider: {
+            providerId,
+            providerSdrn: generateProviderSDRN(providerId),
+        },
+    };
+}

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/referrer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const builder = () => {
+    if (pulse_utils_1.isBrowser && document.referrer) {
+        return {
+            page: {
+                referrer: {
+                    url: document.referrer,
+                },
+            },
+        };
+    }
+    return {
+        page: {},
+    };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/session.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSession = exports.readAndParse = exports.builder = void 0;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const uuid_1 = require("uuid");
+const { USE_LOCALSTORAGE } = pulse_utils_1.cookieConfig;
+const SESSION_STORAGE_KEY = '_pulsesession';
+// 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
+const builder = (createdAt) => {
+    const oldSession = (0, exports.readSession)();
+    const newSession = updateSession(createdAt, oldSession);
+    writeSession(newSession);
+    const { sessionId, startTime, isFirstEvent } = newSession;
+    return {
+        session: {
+            isFirstEvent,
+            sessionId,
+            startTime,
+            xDomainId: getXDomainId(),
+        },
+    };
+};
+exports.builder = builder;
+// TODO: do we need to save this in the session, as part of the localStorage?
+// or should we just read it from the URL params every time?
+const getXDomainId = () => {
+    if (!pulse_utils_1.isBrowser) {
+        return;
+    }
+    const urlParams = new URLSearchParams(window?.location?.search ?? '');
+    return urlParams.get('x_domain_id') || undefined;
+};
+// Return parsed json from cookie (or localStorage if enabled), or undefined.
+// exported for testing purposes.
+const readAndParse = (storageKey) => {
+    try {
+        const storedSession = (0, pulse_utils_1.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;
+};
+exports.readAndParse = readAndParse;
+// Read and parse session data from localStorage.
+// Any invalid or unreadable data is ignored.
+const readSession = () => {
+    const storedSession = (0, exports.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 { sessionId, startTime: startTime.toISOString(), lastEventTime, isFirstEvent: false };
+        }
+    }
+    return undefined;
+};
+exports.readSession = readSession;
+// Write session data to localStorage
+const writeSession = (session) => {
+    const { sessionId, startTime, lastEventTime } = session;
+    try {
+        const sessionToStore = [sessionId, new Date(startTime).getTime(), lastEventTime.getTime()];
+        const halfHourInDays = 1.0 / (24 * 2);
+        (0, pulse_utils_1.writeCookie)(SESSION_STORAGE_KEY, JSON.stringify(sessionToStore), (0, pulse_utils_1.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
+            pulse_utils_1.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: (0, uuid_1.v4)(),
+        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,
+        // to ensure backwards compatibility between the new sessionId format and old sessions
+        // we need to remove the SDRN prefix from old sessionIds
+        sessionId: session.sessionId.replace('sdrn:schibsted:session:', ''),
+        isFirstEvent: false,
+        lastEventTime: eventCreationDate,
+    };
+};

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/time.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (createdAt) => {
+    const isoString = createdAt.toISOString();
+    return {
+        time: {
+            createdAt: isoString,
+            // setting sentAt here, so we please the typescript gods, however, this value will be overwritten later
+            // sentAt will be set just before sending the event
+            sentAt: isoString, // this will be set just before sending the event
+        },
+    };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/trackerBuilder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (autoTrackerVersion, isHybrid, version) => {
+    return {
+        tracker: {
+            autoTrackerVersion,
+            isAutoTracker: !!autoTrackerVersion,
+            isHybrid,
+            trackerType: 'JS',
+            version,
+        },
+    };
+};
+exports.builder = builder;

package/node_modules/@schibsted/tpaas-event-builder/dist/cjs/builders/user.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = (user) => {
+    if (!user) {
+        console.warn('User is not set, inferring the user is anonymous (logged out).');
+        return {};
+    }
+    const { hasAnySubscription, region, id, realm } = user;
+    if (!id || !id.toString().trim()) {
+        // the user is anonymous (logged out)
+        return {};
+    }
+    return {
+        user: {
+            hasAnySubscription,
+            region,
+            userId: id,
+            userSdrn: generateUserSDRN(id, realm),
+        },
+    };
+};
+exports.builder = builder;
+function generateUserSDRN(id, realm = '__REALM_NOT_SET__') {
+    return `sdrn:${realm}:user:${id}`;
+}