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

package/dist/cjs/cis-sync/cis-browser.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncWithCis = syncWithCis;
+const utils_1 = require("../utils");
+const pulse_cookie_1 = require("./pulse-cookie");
+const { PULSE_COOKIE_KEY } = utils_1.cookieConfig;
+const CIS_HOST = 'https://cis.schibsted.com';
+const CIS_PATH = '/api/v2/identify';
+let preferredCISHost = 'cis.schibsted.com';
+/**
+ * CIS has two endpoints:
+ * - anonymous identifier keys (/identify/guest),
+ * - identifiable keys (/identify/user)
+ */
+const CISActorType = {
+    USER: 'user',
+    GUEST: 'guest',
+};
+/**
+ * Resolves CIS path param
+ * @param actorId
+ */
+const getActorPath = (actorId) => {
+    let endpoint = CISActorType.GUEST;
+    if (actorId) {
+        endpoint = CISActorType.USER;
+    }
+    return `${CIS_PATH}/${endpoint}`;
+};
+const cisFetchHeaders = new Headers({
+    'Content-Type': 'application/json',
+});
+const CIS_MAX_REDIRECT_ATTEMPTS = 2;
+const CIS_DEFAULT_REALM = 'schibsted.com';
+const cisRequestMap = new Map();
+/**
+ * Call CIS with the current user information.
+ *
+ * @private
+ */
+async function cisFetch({ adChoicesEnabled, cisLocation, clientId, includeAdvertising, resolvedJwe: jwe, trackerType, trackerVersion, userId, vendors, } = {}) {
+    const basePath = cisLocation?.endsWith('/') ? cisLocation.slice(0, -1) : cisLocation;
+    const path = `${basePath}${getActorPath(userId)}`;
+    const features = adChoicesEnabled === true ? ['COP'] : undefined;
+    // Using 'toString' here to make unit test mock comparisons easier
+    return fetch(new URL(path).toString(), {
+        method: 'POST',
+        credentials: 'include',
+        headers: cisFetchHeaders,
+        body: JSON.stringify({
+            clientId,
+            features,
+            includeAdvertising,
+            jwe,
+            trackerType,
+            trackerVersion,
+            userId,
+            vendors,
+        }),
+    });
+}
+/** Identify recursively until no `redirectToHost` field */
+async function cisFetchWithRedirect({ adChoicesEnabled, cisLocation, clientId, includeAdvertising, resolvedJwe, trackerType, trackerVersion, userId, vendors, }, redirectAttempts = 0) {
+    if (redirectAttempts > CIS_MAX_REDIRECT_ATTEMPTS) {
+        throw new Error('Too many CIS redirects');
+    }
+    const response = await cisFetch({
+        adChoicesEnabled,
+        cisLocation,
+        clientId,
+        includeAdvertising,
+        resolvedJwe,
+        trackerType,
+        trackerVersion,
+        userId,
+        vendors,
+    });
+    const { data: responseData } = await response.json();
+    if (responseData.redirectToHost) {
+        preferredCISHost = responseData.redirectToHost;
+        return cisFetchWithRedirect({
+            adChoicesEnabled,
+            resolvedJwe,
+            userId,
+            cisLocation: `https://${preferredCISHost}`,
+            clientId,
+            trackerType,
+            trackerVersion,
+            includeAdvertising,
+            vendors,
+        }, redirectAttempts + 1);
+    }
+    return responseData;
+}
+let currentCisRequest = Promise.resolve((0, pulse_cookie_1.parsePulseCookies)());
+/**
+ * Call CIS serially if needed, 'needed' being evaluated when the call reaches the top of the queue.
+ *
+ * @private
+ */
+async function serialSyncWithCis(shortUserId, 
+// biome-ignore lint/style/useDefaultParameterLast: -
+forceSync = false, cisLocation, nativeJwe, realm, clientId, trackerType, trackerVersion, options) {
+    // Re-read our sync state as the previous cis request might have
+    // made this sync obsolete.
+    const cookie = (0, utils_1.readCookie)(PULSE_COOKIE_KEY);
+    const { syncWithCis: shouldSyncWithCIS, syncWithCisReason: requestReason } = (0, pulse_cookie_1.getSyncState)(shortUserId, {
+        cookie,
+        ...options,
+    });
+    const { jwe, prevUserId } = (0, pulse_cookie_1.parsePulseCookies)(cookie);
+    const requestHandlerFn = async () => {
+        // For reason === login, we know shortUserId should be set and should be trusted.
+        // For reason === logout, we know shortUserId is unset, but should be trusted.
+        // For reason === initialise, we can't trust shortUserId and should use prevUserId instead.
+        // For reason === refresh, we could use either as they should be in sync, but using
+        // prevUserId makes it possible to do regular syncs without access to an event, so we use that.
+        const resolvedJwe = nativeJwe || jwe; // always send a nativeJwe when present. Hybrid app use case;
+        let prominentUserId = shortUserId;
+        if (requestReason !== pulse_cookie_1.CisSyncReason.Login && requestReason !== pulse_cookie_1.CisSyncReason.Logout) {
+            prominentUserId = prevUserId;
+        }
+        const userId = prominentUserId && `sdrn:${realm}:user:${prominentUserId}`;
+        if (shouldSyncWithCIS || forceSync) {
+            try {
+                const cisResponseData = await cisFetchWithRedirect({
+                    resolvedJwe,
+                    userId,
+                    cisLocation,
+                    clientId,
+                    adChoicesEnabled: options?.adChoicesEnabled,
+                    trackerType,
+                    trackerVersion,
+                    includeAdvertising: options?.includeAdvertising,
+                    vendors: options?.vendors,
+                });
+                const refreshAfterTimestamp = cisResponseData.refreshAfter
+                    ? new Date(cisResponseData.refreshAfter).getTime()
+                    : 0;
+                const storageData = {
+                    ppId: {},
+                    ...cisResponseData,
+                    prevUserId: shortUserId,
+                    refreshAfterTimestamp,
+                    includeAdvertising: options?.includeAdvertising,
+                };
+                /**
+                 * AdChoices restricts the issuing of PPID.
+                 * When the user has NOT consented to advertising purpose, and the application runs with AdChoices rules, the sdk
+                 * cannot delegate or persist the PPID in localStorage.
+                 * `adChoicesEnabled` must be explicitly set to `true`. No room for truthy values here.
+                 */
+                if (options?.adChoicesEnabled === true && options?.includeAdvertising !== true) {
+                    storageData.ppId = {};
+                }
+                (0, pulse_cookie_1.serializePulseCookie)(storageData);
+                return storageData;
+            }
+            catch (_err) {
+                // silent error.
+            }
+            finally {
+                if (options?.trackerId) {
+                    cisRequestMap.delete(options.trackerId);
+                }
+            }
+        }
+        return (0, pulse_cookie_1.parsePulseCookies)();
+    };
+    if (options?.trackerId) {
+        const { request, requestReason: onGoingRequestReason } = cisRequestMap.get(options.trackerId) || {};
+        let ongoingRequest = request;
+        if (!ongoingRequest || onGoingRequestReason !== requestReason || forceSync) {
+            ongoingRequest = requestHandlerFn();
+            cisRequestMap.set(options.trackerId, { request: ongoingRequest, requestReason });
+        }
+        return ongoingRequest;
+    }
+    // maintaining the old behaviour for when there is no "internalId" passed to the tracker.
+    currentCisRequest = currentCisRequest.then(requestHandlerFn);
+    return currentCisRequest;
+}
+/**
+ * Sync with CIS
+ *
+ * This method deals with all communication and communication with dependent systems (currently AppNexus and Norstat).
+ *
+ * An optional user id should be provided if a tracker have received a logged in state. Providing a new user id
+ * (different from a previous user id, serialized to the pulse cookie) will cause a "blocking call" to CIS (the
+ * returned promise will not resolve before the communication is done). This is done because CIS could provide new data
+ * regarding opt-out.
+ *
+ * The returned promise will also be blocking if no pulse cookie is found. Pulse requires environmentIds generated
+ * server side so one have to wait to be allocated to one.
+ *
+ * In other context CIS could or could not be called but the returned promise will resolve immediately. If CIS have
+ * been called recently there is no point in calling it again. In a different case, if a refresh call to CIS is required
+ * it doesn't mean that other systems have to wait of it. Both cases will return a promise that resolves more or less
+ * immediately.
+ */
+async function syncWithCis(shortUserId, nativeJwe, userServiceLocation, realm = CIS_DEFAULT_REALM, clientId, trackerType, trackerVersion, options) {
+    const { syncWithCis: shouldSyncWithCIS, waitForCis: shouldWaitForCIS } = (0, pulse_cookie_1.getSyncState)(shortUserId, options);
+    const storageData = (0, pulse_cookie_1.parsePulseCookies)();
+    const cisLocation = userServiceLocation || CIS_HOST;
+    let cisRequest = Promise.resolve(storageData);
+    if (shouldSyncWithCIS || options?.forceSync) {
+        cisRequest = serialSyncWithCis(shortUserId, Boolean(options?.forceSync), cisLocation, nativeJwe, realm, clientId || '', trackerType || '', trackerVersion || '', options);
+    }
+    // If `shouldWaitForCIS` is false the update with CIS is only a "soft sync" and
+    // shouldn't block other operations. This is the case when the browser has a
+    // _pulse2data cookie and the user haven't logged in or out. When the user do
+    // log in we have to wait to avoid sending events with user ids after logging
+    // out or without ids after logging in.
+    let ongoingCISRequest = Promise.resolve(storageData);
+    if (shouldWaitForCIS || options?.forceSync) {
+        ongoingCISRequest = cisRequest;
+    }
+    return ongoingCISRequest;
+}

package/{node_modules/@schibsted/pulse-cis-sync/dist/cjs → dist/cjs/cis-sync}/cis.js

@@ -4,4 +4,3 @@ exports.syncWithCis = syncWithCis;
 function syncWithCis() {
     return Promise.reject(new Error('CIS is not implemented for non-browser environments'));
 }
-//# sourceMappingURL=cis.js.map

package/dist/cjs/cis-sync/eventEmitter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class EventEmitter {
+    constructor() {
+        this.events = {};
+    }
+    on(event, callback) {
+        if (typeof this.events[event] !== 'object') {
+            this.events[event] = [];
+        }
+        this.events[event].push(callback);
+    }
+    off(event, callback) {
+        this.removeListener(event, callback);
+    }
+    removeListener(event, callback) {
+        if (typeof this.events[event] === 'object') {
+            const index = this.events[event].indexOf(callback);
+            if (index !== -1) {
+                this.events[event].splice(index, 1);
+            }
+        }
+    }
+    removeAllListeners() {
+        this.events = {};
+    }
+    emit(event, value) {
+        if (typeof this.events[event] === 'object') {
+            this.events[event]
+                .filter((cb) => cb != null)
+                .forEach((cb) => {
+                cb(value);
+            });
+        }
+    }
+}
+exports.default = EventEmitter;

package/{node_modules/@schibsted/pulse-cis-sync/dist/cjs → dist/cjs/cis-sync}/index.js

@@ -9,4 +9,3 @@ Object.defineProperty(exports, "clearCookieJweIfStale", { enumerable: true, get:
 Object.defineProperty(exports, "eventEmitter", { enumerable: true, get: function () { return pulse_cookie_1.eventEmitter; } });
 Object.defineProperty(exports, "parsePulseCookies", { enumerable: true, get: function () { return pulse_cookie_1.parsePulseCookies; } });
 Object.defineProperty(exports, "resetRefreshAfter", { enumerable: true, get: function () { return pulse_cookie_1.resetRefreshAfter; } });
-//# sourceMappingURL=index.js.map

package/{node_modules/@schibsted/pulse-cis-sync/dist/cjs → dist/cjs/cis-sync}/pulse-cookie.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -22,50 +11,46 @@ exports.clearCookieAdvertisingIds = clearCookieAdvertisingIds;
 exports.clearCookieJweIfStale = clearCookieJweIfStale;
 exports.resetRefreshAfter = resetRefreshAfter;
 exports.getSyncState = getSyncState;
-var pulse_utils_1 = require("@schibsted/pulse-utils");
-var eventEmitter_1 = __importDefault(require("./eventEmitter"));
-var pulseStorage_1 = __importDefault(require("./storage/pulseStorage"));
-var PULSE_COOKIE_KEY = pulse_utils_1.cookieConfig.PULSE_COOKIE_KEY, ENV_COOKIE_KEY = pulse_utils_1.cookieConfig.ENV_COOKIE_KEY;
-var CIS_POLL_INTERVAL = 900000; // 15 minutes
+const utils_1 = require("../utils");
+const eventEmitter_1 = __importDefault(require("./eventEmitter"));
+const pulseStorage_1 = __importDefault(require("./storage/pulseStorage"));
+const { PULSE_COOKIE_KEY, ENV_COOKIE_KEY } = utils_1.cookieConfig;
+const CIS_POLL_INTERVAL = 900000; // 15 minutes
 /**
  * Responsible for subscribing to, and emitting events.
  */
 exports.eventEmitter = new eventEmitter_1.default();
 function cacheOldEnvironmentId(id) {
     try {
-        var envCookie = '';
-        var oldIds_1 = {};
+        let envCookie = '';
+        let oldIds = {};
         try {
-            envCookie = (0, pulse_utils_1.readCookie)(ENV_COOKIE_KEY);
+            envCookie = (0, utils_1.readCookie)(ENV_COOKIE_KEY);
         }
         catch (_e) { }
         try {
-            oldIds_1 = envCookie ? JSON.parse(envCookie) : [];
+            oldIds = envCookie ? JSON.parse(envCookie) : [];
         }
         catch (_e) { }
-        oldIds_1[id] = Date.now();
-        var idsToCache = Object.keys(oldIds_1)
-            .map(function (envId) { return ({ id: envId, date: oldIds_1[envId] }); })
-            .sort(function (o) { return o.date; })
+        oldIds[id] = Date.now();
+        const idsToCache = Object.keys(oldIds)
+            .map((envId) => ({ id: envId, date: oldIds[envId] }))
+            .sort((o) => o.date)
             .slice(0, 5)
             // biome-ignore lint/performance/noAccumulatingSpread: -
-            .reduce(function (accl, o) {
-            var _a;
-            return (__assign(__assign({}, accl), (_a = {}, _a[o.id] = o.date, _a)));
-        }, {});
-        (0, pulse_utils_1.writeCookie)(ENV_COOKIE_KEY, JSON.stringify(idsToCache), (0, pulse_utils_1.getRootDomain)(), 365);
+            .reduce((accl, o) => ({ ...accl, [o.id]: o.date }), {});
+        (0, utils_1.writeCookie)(ENV_COOKIE_KEY, JSON.stringify(idsToCache), (0, utils_1.getRootDomain)(), 365);
     }
     catch (_e) { }
 }
-function parsePulseCookies(cookie) {
-    if (cookie === void 0) { cookie = (0, pulse_utils_1.readCookie)(PULSE_COOKIE_KEY); }
-    var values = decodeURIComponent(cookie).split(',');
+function parsePulseCookies(cookie = (0, utils_1.readCookie)(PULSE_COOKIE_KEY)) {
+    let values = decodeURIComponent(cookie).split(',');
     // Cookie is in an unknown, possibly old format. Will be ignored.
     if (values.length !== 10) {
         values = [];
     }
-    var altEnvCookie = (0, pulse_utils_1.readCookie)(ENV_COOKIE_KEY);
-    var altEnvIds;
+    const altEnvCookie = (0, utils_1.readCookie)(ENV_COOKIE_KEY);
+    let altEnvIds;
     if (altEnvIds) {
         try {
             altEnvIds = JSON.parse(altEnvCookie);
@@ -74,8 +59,8 @@ function parsePulseCookies(cookie) {
             altEnvIds = undefined;
         }
     }
-    var ppId = pulseStorage_1.default.getPPIDsFromStorage();
-    var cisCache = pulseStorage_1.default.getCisCacheFromStorage();
+    const ppId = pulseStorage_1.default.getPPIDsFromStorage();
+    const cisCache = pulseStorage_1.default.getCisCacheFromStorage();
     return {
         environmentId: values[0],
         prevUserId: values[2] ? values[2] : undefined,
@@ -86,17 +71,17 @@ function parsePulseCookies(cookie) {
         doTracking: true,
         pixelInjected: values[8] ? values[8] === 'true' : undefined,
         adId: values[9],
-        altEnvIds: altEnvIds,
+        altEnvIds,
         visitorIdPlaceholder: values[1],
-        ppId: ppId,
-        includeAdvertising: cisCache === null || cisCache === void 0 ? void 0 : cisCache.includeAdvertising,
+        ppId,
+        includeAdvertising: cisCache?.includeAdvertising,
     };
 }
 function serializePulseCookie(input) {
-    var _a = input || {}, _b = _a.environmentId, environmentId = _b === void 0 ? '' : _b, _c = _a.prevUserId, prevUserId = _c === void 0 ? '' : _c, _d = _a.jwe, jwe = _d === void 0 ? '' : _d, _f = _a.pixelInjected, pixelInjected = _f === void 0 ? '' : _f, _g = _a.adId, adId = _g === void 0 ? '' : _g, _h = _a.visitorIdPlaceholder, visitorIdPlaceholder = _h === void 0 ? 'v' : _h, _j = _a.ppId, ppId = _j === void 0 ? {} : _j, refreshAfterTimestamp = _a.refreshAfterTimestamp, includeAdvertising = _a.includeAdvertising;
-    var now = Date.now();
-    var refreshCisAfterTimestamp = refreshAfterTimestamp || new Date(now + CIS_POLL_INTERVAL).getTime();
-    var cookieString = [
+    const { environmentId = '', prevUserId = '', jwe = '', pixelInjected = '', adId = '', visitorIdPlaceholder = 'v', ppId = {}, refreshAfterTimestamp, includeAdvertising, } = input || {};
+    const now = Date.now();
+    const refreshCisAfterTimestamp = refreshAfterTimestamp || new Date(now + CIS_POLL_INTERVAL).getTime();
+    const cookieString = [
         environmentId,
         visitorIdPlaceholder,
         prevUserId,
@@ -109,8 +94,8 @@ function serializePulseCookie(input) {
         adId,
     ].join(',');
     pulseStorage_1.default.setPPIDsToStorage(ppId);
-    pulseStorage_1.default.setCisCacheToStorage({ includeAdvertising: includeAdvertising });
-    (0, pulse_utils_1.writeCookie)(PULSE_COOKIE_KEY, cookieString, (0, pulse_utils_1.getRootDomain)(), 2 * 365);
+    pulseStorage_1.default.setCisCacheToStorage({ includeAdvertising });
+    (0, utils_1.writeCookie)(PULSE_COOKIE_KEY, cookieString, (0, utils_1.getRootDomain)(), 2 * 365);
     exports.eventEmitter.emit('environmentIdSet', environmentId);
     exports.eventEmitter.emit('jweSet', jwe);
 }
@@ -128,7 +113,14 @@ var CisSyncReason;
  * @deprecated Advertising Identifiers methods will be removed in the next major version.
  */
 function clearCookieAdvertisingIds() {
-    var cookieValues = __assign(__assign({}, parsePulseCookies()), { adId: '', anId: '', includeAdvertising: false, jwe: '', syncWithAppNexus: 0 });
+    const cookieValues = {
+        ...parsePulseCookies(),
+        adId: '',
+        anId: '',
+        includeAdvertising: false,
+        jwe: '',
+        syncWithAppNexus: 0,
+    };
     serializePulseCookie(cookieValues);
     return cookieValues;
 }
@@ -142,9 +134,8 @@ function clearCookieAdvertisingIds() {
  * send any nativeJwe in config.
  * @deprecated Advertising Identifiers methods will be removed in the next major version.
  */
-function clearCookieJweIfStale(jwe) {
-    if (jwe === void 0) { jwe = ''; }
-    var currentJwe = parsePulseCookies().jwe;
+function clearCookieJweIfStale(jwe = '') {
+    const { jwe: currentJwe } = parsePulseCookies();
     if (jwe && currentJwe !== jwe) {
         clearCookieAdvertisingIds();
     }
@@ -154,7 +145,10 @@ function clearCookieJweIfStale(jwe) {
  * @param refreshAfterDateTime
  */
 function resetRefreshAfter(refreshAfterDateTime) {
-    var cookieValues = __assign(__assign({}, parsePulseCookies()), { refreshAfterTimestamp: refreshAfterDateTime ? refreshAfterDateTime.getTime() : Date.now() });
+    const cookieValues = {
+        ...parsePulseCookies(),
+        refreshAfterTimestamp: refreshAfterDateTime ? refreshAfterDateTime.getTime() : Date.now(),
+    };
     serializePulseCookie(cookieValues);
     return cookieValues;
 }
@@ -164,7 +158,7 @@ function resetRefreshAfter(refreshAfterDateTime) {
  * @param prevUserId previous user's id stored in the application
  * @returns
  */
-var shouldLogin = function (userId, prevUserId) {
+const shouldLogin = (userId, prevUserId) => {
     return Boolean(userId) && String(userId) !== String(prevUserId);
 };
 /**
@@ -173,7 +167,7 @@ var shouldLogin = function (userId, prevUserId) {
  * @param prevUserId previous user's id stored in the application
  * @returns
  */
-var shouldLogout = function (userId, prevUserId) {
+const shouldLogout = (userId, prevUserId) => {
     return !userId && String(userId) !== String(prevUserId);
 };
 /**
@@ -181,7 +175,7 @@ var shouldLogout = function (userId, prevUserId) {
  * @param currentTimestamp now, expressed as timestamp in ms
  * @param refreshAfterTimestamp threshold, expressed as timestamp in ms
  */
-var shouldRefresh = function (currentTimestamp, refreshAfterTimestamp) {
+const shouldRefresh = (currentTimestamp, refreshAfterTimestamp) => {
     return refreshAfterTimestamp && currentTimestamp > refreshAfterTimestamp;
 };
 /**
@@ -190,7 +184,7 @@ var shouldRefresh = function (currentTimestamp, refreshAfterTimestamp) {
  * @param updatedIncludeAdvertising newly processed value  for includeAdvertising
  * @deprecated Advertising Identifiers methods will be removed in the next major version.
  */
-var shouldRefetchAdvertisingIdentifiers = function (currentIncludeAdvertising, updatedIncludeAdvertising) {
+const shouldRefetchAdvertisingIdentifiers = (currentIncludeAdvertising, updatedIncludeAdvertising) => {
     return currentIncludeAdvertising !== updatedIncludeAdvertising;
 };
 /**
@@ -200,9 +194,7 @@ var shouldRefetchAdvertisingIdentifiers = function (currentIncludeAdvertising, u
  * @param includeAdvertising expresses whether advertising ids are expected in the stored state of the application
  * @param vendors for which vendors the application is expecting advertising ids
  */
-var shouldInitialise = function (cookieInput, currentCookie, includeAdvertising, vendors) {
-    if (includeAdvertising === void 0) { includeAdvertising = false; }
-    if (vendors === void 0) { vendors = []; }
+const shouldInitialise = (cookieInput, currentCookie, includeAdvertising = false, vendors = []) => {
     return (!cookieInput ||
         cookieInput.indexOf('undefined') !== -1 || // 'undefined' should not be a value in the raw cookie. Treat as invalid.
         !currentCookie.environmentId ||
@@ -215,11 +207,10 @@ var shouldInitialise = function (cookieInput, currentCookie, includeAdvertising,
  * @param options
  * @returns {SyncState}
  */
-function getSyncState(userId, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.cookie, cookieInput = _a === void 0 ? (0, pulse_utils_1.readCookie)(PULSE_COOKIE_KEY) : _a, includeAdvertising = options.includeAdvertising, vendors = options.vendors;
-    var currentCookie = parsePulseCookies(cookieInput);
-    var currentTimestamp = Date.now();
+function getSyncState(userId, options = {}) {
+    const { cookie: cookieInput = (0, utils_1.readCookie)(PULSE_COOKIE_KEY), includeAdvertising, vendors } = options;
+    const currentCookie = parsePulseCookies(cookieInput);
+    const currentTimestamp = Date.now();
     /*
      * This case only handles login.  For example when we don't necessarily have an event (tracker.update({actor: ...})
      * might or might not have been called), then we only want to sync if we DO have a userId, and if that userId is not
@@ -273,4 +264,3 @@ function getSyncState(userId, options) {
         syncWithCis: false,
     };
 }
-//# sourceMappingURL=pulse-cookie.js.map

package/{node_modules/@schibsted/pulse-cis-sync/dist/cjs → dist/cjs/cis-sync}/storage/pulseStorage.js

@@ -33,45 +33,53 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-var storage = __importStar(require("./storage"));
-var pulseStorageKeys = {
+exports.pulseStorageKeys = void 0;
+const storage = __importStar(require("./storage"));
+exports.pulseStorageKeys = {
     PULSE_PPID_STORAGE_KEY: '_pulse.internal.identity.ppid',
     PULSE_CIS_CACHE_STORAGE_KEY: '_pulse.internal.identity.cis',
 };
-var getPPIDsFromStorage = function () {
-    var _a;
+const getPPIDsFromStorage = () => {
     try {
-        var webStorage = storage.getStorage();
-        return JSON.parse((_a = webStorage.getItem(pulseStorageKeys.PULSE_PPID_STORAGE_KEY)) !== null && _a !== void 0 ? _a : '');
+        const webStorage = storage.getStorage();
+        return JSON.parse(webStorage.getItem(exports.pulseStorageKeys.PULSE_PPID_STORAGE_KEY) ?? '{}');
     }
     catch (_err) {
         return {};
     }
 };
-var setPPIDsToStorage = function (ppid) {
+const setPPIDsToStorage = (ppid) => {
     try {
-        var webStorage = storage.getStorage();
-        webStorage.setItem(pulseStorageKeys.PULSE_PPID_STORAGE_KEY, JSON.stringify(ppid));
+        const webStorage = storage.getStorage();
+        /**
+         * we maintain the interface consistent with the ppId api, but there is no need to persist an empty object in
+         * localStorage. We normalise back when we read the value.
+         * @see getPPIDsFromStorage
+         */
+        if (Object.keys(ppid).length === 0) {
+            webStorage.removeItem(exports.pulseStorageKeys.PULSE_PPID_STORAGE_KEY);
+            return true;
+        }
+        webStorage.setItem(exports.pulseStorageKeys.PULSE_PPID_STORAGE_KEY, JSON.stringify(ppid));
         return true;
     }
     catch (_err) {
         return false;
     }
 };
-var getCisCacheFromStorage = function () {
-    var _a;
+const getCisCacheFromStorage = () => {
     try {
-        var webStorage = storage.getStorage();
-        return JSON.parse((_a = webStorage.getItem(pulseStorageKeys.PULSE_CIS_CACHE_STORAGE_KEY)) !== null && _a !== void 0 ? _a : '');
+        const webStorage = storage.getStorage();
+        return JSON.parse(webStorage.getItem(exports.pulseStorageKeys.PULSE_CIS_CACHE_STORAGE_KEY) ?? '{}');
     }
     catch (_err) {
         return {};
     }
 };
-var setCisCacheToStorage = function (cisPayload) {
+const setCisCacheToStorage = (cisPayload) => {
     try {
-        var webStorage = storage.getStorage();
-        webStorage.setItem(pulseStorageKeys.PULSE_CIS_CACHE_STORAGE_KEY, JSON.stringify(cisPayload));
+        const webStorage = storage.getStorage();
+        webStorage.setItem(exports.pulseStorageKeys.PULSE_CIS_CACHE_STORAGE_KEY, JSON.stringify(cisPayload));
         return true;
     }
     catch (_err) {
@@ -79,9 +87,8 @@ var setCisCacheToStorage = function (cisPayload) {
     }
 };
 exports.default = {
-    getCisCacheFromStorage: getCisCacheFromStorage,
-    setCisCacheToStorage: setCisCacheToStorage,
-    getPPIDsFromStorage: getPPIDsFromStorage,
-    setPPIDsToStorage: setPPIDsToStorage,
+    getCisCacheFromStorage,
+    setCisCacheToStorage,
+    getPPIDsFromStorage,
+    setPPIDsToStorage,
 };
-//# sourceMappingURL=pulseStorage.js.map

package/dist/cjs/cis-sync/storage/storage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorage = void 0;
+const utils_1 = require("../../utils");
+const getStorage = (storageType = 'localStorage') => {
+    const storage = utils_1.webApi[storageType];
+    const getItem = (key) => {
+        return utils_1.isBrowser && storage ? storage.getItem(key) : undefined;
+    };
+    const removeItem = (key) => {
+        if (utils_1.isBrowser && storage)
+            storage.removeItem(key);
+    };
+    const setItem = (key, value) => {
+        if (utils_1.isBrowser && storage)
+            storage.setItem(key, value);
+    };
+    return {
+        getItem,
+        removeItem,
+        setItem,
+    };
+};
+exports.getStorage = getStorage;

package/dist/cjs/createPulseTracker.js

@@ -10,20 +10,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPulseTracker = createPulseTracker;
-const pulse_utils_1 = require("@schibsted/pulse-utils/");
 const Tracker_1 = __importDefault(require("./Tracker"));
+const utils_1 = require("./utils");
 /**
  * Flags whether the Pulse Tracker creation process has been started.
  */
 function isTrackerCreated() {
-    return pulse_utils_1.isBrowser && !!window.__pulseTracker;
+    return utils_1.isBrowser && !!window.__pulseTracker;
 }
 /**
  * Make the given tracker instance globally accessible
  * @param singleton
  */
 function attachTrackerToWindow(singleton) {
-    if (pulse_utils_1.isBrowser) {
+    if (utils_1.isBrowser) {
         window.__pulseTracker = singleton;
     }
 }
@@ -36,7 +36,7 @@ function attachTrackerToWindow(singleton) {
  * @throws - If the Pulse Tracker has already been created (or creation is already in progress).
  */
 async function createPulseTracker({ clientId, config, builders }) {
-    if (!pulse_utils_1.isBrowser) {
+    if (!utils_1.isBrowser) {
         throw new Error('createPulseTracker is only available in browser environments');
     }
     if (isTrackerCreated()) {