@cloudcare/browser-core 3.2.4 → 3.2.6

package/src/session/sessionStore.js

@@ -1,170 +1,225 @@
-import { COOKIE_ACCESS_DELAY } from '../browser/cookie'
+import { clearInterval, setInterval } from '../helper/timer'
 import { Observable } from '../helper/observable'
-import { dateNow, UUID, throttle, ONE_SECOND } from '../helper/tools'
-import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { ONE_SECOND, dateNow, throttle, UUID, assign } from '../helper/tools'
+import { selectCookieStrategy, initCookieStrategy } from './sessionInCookie'
 import {
-  retrieveSession,
-  withCookieLockAccess,
-  clearSession
-} from './sessionCookieStore'
-import { clearInterval, setInterval } from '../helper/timer'
+  getExpiredSessionState,
+  isSessionInExpiredState,
+  isSessionInNotStartedState,
+  isSessionStarted
+} from './sessionState'
+import {
+  initLocalStorageStrategy,
+  selectLocalStorageStrategy
+} from './sessionInLocalStorage'
+import { processSessionStoreOperations } from './sessionStoreOperations'
+
+/**
+ * Every second, the storage will be polled to check for any change that can occur
+ * to the session state in another browser tab, or another window.
+ * This value has been determined from our previous cookie-only implementation.
+ */
+export const STORAGE_POLL_DELAY = ONE_SECOND
+
+/**
+ * Checks if cookies are available as the preferred storage
+ * Else, checks if LocalStorage is allowed and available
+ */
+export function selectSessionStoreStrategyType(initConfiguration) {
+  let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
+  if (
+    !sessionStoreStrategyType &&
+    initConfiguration.allowFallbackToLocalStorage
+  ) {
+    sessionStoreStrategyType = selectLocalStorageStrategy()
+  }
+  return sessionStoreStrategyType
+}
 
-export var STORAGE_POLL_DELAY = ONE_SECOND
 /**
  * Different session concepts:
  * - tracked, the session has an id and is updated along the user navigation
  * - not tracked, the session does not have an id but it is updated along the user navigation
  * - inactive, no session in store or session expired, waiting for a renew session
  */
-export function startSessionStore(options, productKey, computeSessionState) {
-  var renewObservable = new Observable()
-  var expireObservable = new Observable()
-
-  var watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
-  var sessionCache = retrieveActiveSession()
-  var _throttleExpandOrRenewSession = throttle(function () {
-    var isTracked
-    withCookieLockAccess({
-      options: options,
-      process: function (cookieSession) {
-        var synchronizedSession = synchronizeSession(cookieSession)
-        isTracked = expandOrRenewCookie(synchronizedSession)
-        return synchronizedSession
-      },
-      after: function (cookieSession) {
-        if (isTracked && !hasSessionInCache()) {
-          renewSession(cookieSession)
+export function startSessionStore(
+  sessionStoreStrategyType,
+  productKey,
+  computeSessionState
+) {
+  const renewObservable = new Observable()
+  const expireObservable = new Observable()
+  const sessionStateUpdateObservable = new Observable()
+  const sessionStoreStrategy =
+    sessionStoreStrategyType.type === 'Cookie'
+      ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)
+      : initLocalStorageStrategy()
+  const { expireSession } = sessionStoreStrategy
+
+  const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
+  let sessionCache
+
+  startSession()
+
+  const {
+    throttled: throttledExpandOrRenewSession,
+    cancel: cancelExpandOrRenewSession
+  } = throttle(function () {
+    processSessionStoreOperations(
+      {
+        process: function (sessionState) {
+          if (isSessionInNotStartedState(sessionState)) {
+            return
+          }
+
+          const synchronizedSession = synchronizeSession(sessionState)
+          expandOrRenewSessionState(synchronizedSession)
+          return synchronizedSession
+        },
+        after: function (sessionState) {
+          if (isSessionStarted(sessionState) && !hasSessionInCache()) {
+            renewSessionInCache(sessionState)
+          }
+          sessionCache = sessionState
         }
-        sessionCache = cookieSession
-      }
-    })
+      },
+      sessionStoreStrategy
+    )
   }, STORAGE_POLL_DELAY)
-  var throttledExpandOrRenewSession = _throttleExpandOrRenewSession.throttled
-  var cancelExpandOrRenewSession = _throttleExpandOrRenewSession.cancel
-  //   function expandOrRenewSession() {
-  //     var isTracked
-  //     withCookieLockAccess({
-  //       options: options,
-  //       process: function (cookieSession) {
-  //         var synchronizedSession = synchronizeSession(cookieSession)
-  //         isTracked = expandOrRenewCookie(synchronizedSession)
-  //         return synchronizedSession
-  //       },
-  //       after: function (cookieSession) {
-  //         if (isTracked && !hasSessionInCache()) {
-  //           renewSession(cookieSession)
-  //         }
-  //         sessionCache = cookieSession
-  //       }
-  //     })
-  //   }
 
   function expandSession() {
-    withCookieLockAccess({
-      options: options,
-      process: function (cookieSession) {
-        return hasSessionInCache()
-          ? synchronizeSession(cookieSession)
-          : undefined
-      }
-    })
+    processSessionStoreOperations(
+      {
+        process: function (sessionState) {
+          return hasSessionInCache()
+            ? synchronizeSession(sessionState)
+            : undefined
+        }
+      },
+      sessionStoreStrategy
+    )
   }
 
   /**
    * allows two behaviors:
-   * - if the session is active, synchronize the session cache without updating the session cookie
-   * - if the session is not active, clear the session cookie and expire the session cache
+   * - if the session is active, synchronize the session cache without updating the session store
+   * - if the session is not active, clear the session store and expire the session cache
    */
   function watchSession() {
-    withCookieLockAccess({
-      options: options,
-      process: function (cookieSession) {
-        return !isActiveSession(cookieSession) ? {} : undefined
+    processSessionStoreOperations(
+      {
+        process: function (sessionState) {
+          return isSessionInExpiredState(sessionState)
+            ? getExpiredSessionState()
+            : undefined
+        },
+        after: synchronizeSession
       },
-      after: synchronizeSession
-    })
+      sessionStoreStrategy
+    )
   }
 
-  function synchronizeSession(cookieSession) {
-    if (!isActiveSession(cookieSession)) {
-      cookieSession = {}
+  function synchronizeSession(sessionState) {
+    if (isSessionInExpiredState(sessionState)) {
+      sessionState = getExpiredSessionState()
     }
     if (hasSessionInCache()) {
-      if (isSessionInCacheOutdated(cookieSession)) {
+      if (isSessionInCacheOutdated(sessionState)) {
         expireSessionInCache()
       } else {
-        sessionCache = cookieSession
+        sessionStateUpdateObservable.notify({
+          previousState: sessionCache,
+          newState: sessionState
+        })
+        sessionCache = sessionState
       }
     }
-    return cookieSession
+    return sessionState
+  }
+
+  function startSession() {
+    processSessionStoreOperations(
+      {
+        process: function (sessionState) {
+          if (isSessionInNotStartedState(sessionState)) {
+            return getExpiredSessionState()
+          }
+        },
+        after: function (sessionState) {
+          sessionCache = sessionState
+        }
+      },
+      sessionStoreStrategy
+    )
   }
 
-  function expandOrRenewCookie(cookieSession) {
-    var sessionState = computeSessionState(cookieSession[productKey])
-    var trackingType = sessionState.trackingType
-    var isTracked = sessionState.isTracked
-    cookieSession[productKey] = trackingType
-    if (isTracked && !cookieSession.id) {
-      cookieSession.id = UUID()
-      cookieSession.created = String(dateNow())
+  function expandOrRenewSessionState(sessionState) {
+    if (isSessionInNotStartedState(sessionState)) {
+      return false
+    }
+
+    const { trackingType, isTracked } = computeSessionState(
+      sessionState[productKey]
+    )
+    sessionState[productKey] = trackingType
+    delete sessionState.isExpired
+    if (isTracked && !sessionState.id) {
+      sessionState.id = UUID()
+      sessionState.created = String(dateNow())
     }
-    return isTracked
   }
 
   function hasSessionInCache() {
     return sessionCache[productKey] !== undefined
   }
 
-  function isSessionInCacheOutdated(cookieSession) {
+  function isSessionInCacheOutdated(sessionState) {
     return (
-      sessionCache.id !== cookieSession.id ||
-      sessionCache[productKey] !== cookieSession[productKey]
+      sessionCache.id !== sessionState.id ||
+      sessionCache[productKey] !== sessionState[productKey]
     )
   }
 
   function expireSessionInCache() {
-    sessionCache = {}
+    sessionCache = getExpiredSessionState()
     expireObservable.notify()
   }
 
-  function renewSession(cookieSession) {
-    sessionCache = cookieSession
+  function renewSessionInCache(sessionState) {
+    sessionCache = sessionState
     renewObservable.notify()
   }
 
-  function retrieveActiveSession() {
-    var session = retrieveSession()
-    if (isActiveSession(session)) {
-      return session
-    }
-    return {}
-  }
-
-  function isActiveSession(session) {
-    // created and expire can be undefined for versions which was not storing them
-    // these checks could be removed when older versions will not be available/live anymore
-    return (
-      (session.created === undefined ||
-        dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&
-      (session.expire === undefined || dateNow() < Number(session.expire))
+  function updateSessionState(partialSessionState) {
+    processSessionStoreOperations(
+      {
+        process: function (sessionState) {
+          return assign({}, sessionState, partialSessionState)
+        },
+        after: synchronizeSession
+      },
+      sessionStoreStrategy
     )
   }
 
   return {
     expandOrRenewSession: throttledExpandOrRenewSession,
-    expandSession: expandSession,
+    expandSession,
     getSession: function () {
-      return sessionCache
+      return sessionCache || {}
     },
-    renewObservable: renewObservable,
-    expireObservable: expireObservable,
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable,
+    restartSession: startSession,
     expire: function () {
       cancelExpandOrRenewSession()
-      clearSession(options)
-      synchronizeSession({})
+      expireSession()
+      synchronizeSession(getExpiredSessionState())
     },
     stop: function () {
       clearInterval(watchSessionTimeoutId)
-    }
+    },
+    updateSessionState
   }
 }

package/src/session/sessionStoreOperations.js

@@ -0,0 +1,134 @@
+import { setTimeout } from '../helper/timer'
+import { UUID, assign } from '../helper/tools'
+import {
+  expandSessionState,
+  isSessionInExpiredState,
+  isSessionInNotStartedState
+} from './sessionState'
+
+export const LOCK_RETRY_DELAY = 10
+export const LOCK_MAX_TRIES = 100
+const bufferedOperations = []
+let ongoingOperations
+
+export function processSessionStoreOperations(
+  operations,
+  sessionStoreStrategy,
+  numberOfRetries = 0
+) {
+  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
+  const persistWithLock = function (session) {
+    return persistSession(assign({}, session, { lock: currentLock }))
+  }
+  const retrieveStore = function () {
+    const session = sessionStoreStrategy.retrieveSession()
+    const lock = session.lock
+    if (session.lock) {
+      delete session.lock
+    }
+
+    return {
+      session,
+      lock
+    }
+  }
+
+  if (!ongoingOperations) {
+    ongoingOperations = operations
+  }
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations)
+    return
+  }
+  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    next(sessionStoreStrategy)
+    return
+  }
+  let currentLock
+  let currentStore = retrieveStore()
+  if (isLockEnabled) {
+    // if someone has lock, retry later
+    if (
+      currentStore.lock &&
+      !isSessionInNotStartedState(currentStore.session)
+    ) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+    // acquire lock
+    currentLock = UUID()
+    persistWithLock(currentStore.session)
+    // if lock is not acquired, retry later
+    currentStore = retrieveStore()
+    if (
+      currentStore.lock !== currentLock &&
+      !isSessionInNotStartedState(currentStore.session)
+    ) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  let processedSession = operations.process(currentStore.session)
+  if (isLockEnabled) {
+    // if lock corrupted after process, retry later
+    currentStore = retrieveStore()
+    if (
+      currentStore.lock !== currentLock &&
+      !isSessionInNotStartedState(currentStore.session)
+    ) {
+      retryLater(operations, sessionStoreStrategy, numberOfRetries)
+      return
+    }
+  }
+  if (processedSession) {
+    if (isSessionInExpiredState(processedSession)) {
+      expireSession()
+    } else {
+      expandSessionState(processedSession)
+      isLockEnabled
+        ? persistWithLock(processedSession)
+        : persistSession(processedSession)
+    }
+  }
+  if (isLockEnabled) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isSessionInExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentStore = retrieveStore()
+      if (
+        currentStore.lock !== currentLock &&
+        !isSessionInNotStartedState(currentStore.session)
+      ) {
+        retryLater(operations, sessionStoreStrategy, numberOfRetries)
+        return
+      }
+      persistSession(currentStore.session)
+      processedSession = currentStore.session
+    }
+  }
+  // call after even if session is not persisted in order to perform operations on
+  // up-to-date session state value => the value could have been modified by another tab
+  if (operations.after) {
+    operations.after(processedSession || currentStore.session)
+  }
+  next(sessionStoreStrategy)
+}
+
+function retryLater(operations, sessionStore, currentNumberOfRetries) {
+  setTimeout(function () {
+    processSessionStoreOperations(
+      operations,
+      sessionStore,
+      currentNumberOfRetries + 1
+    )
+  }, LOCK_RETRY_DELAY)
+}
+
+function next(sessionStore) {
+  ongoingOperations = undefined
+  const nextOperations = bufferedOperations.shift()
+  if (nextOperations) {
+    processSessionStoreOperations(nextOperations, sessionStore)
+  }
+}

package/types/index.d.ts

@@ -87,6 +87,10 @@ export interface InitConfiguration {
    * 数据以 application/json 的发送方式，默认text
    */
   sendContentTypeByJson?: boolean | undefined
+  /**
+   * 在 cookie 不可用的情况下，可以开启该选项，把数据储存到 localstorage
+   */
+  allowFallbackToLocalStorage?: boolean | undefined
 }
 export enum TraceType {
   DDTRACE = 'ddtrace',

package/cjs/session/sessionCookieStore.js

@@ -1,156 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SESSION_COOKIE_NAME = exports.MAX_NUMBER_OF_LOCK_RETRIES = exports.LOCK_RETRY_DELAY = void 0;
-exports.clearSession = clearSession;
-exports.persistSession = persistSession;
-exports.retrieveSession = retrieveSession;
-exports.toSessionString = toSessionString;
-exports.withCookieLockAccess = withCookieLockAccess;
-var _cookie = require("../browser/cookie");
-var _tools = require("../helper/tools");
-var _sessionConstants = require("./sessionConstants");
-var _timer = require("../helper/timer");
-var SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;
-var SESSION_ENTRY_SEPARATOR = '&';
-var SESSION_COOKIE_NAME = '_dataflux_s';
-
-// arbitrary values
-exports.SESSION_COOKIE_NAME = SESSION_COOKIE_NAME;
-var LOCK_RETRY_DELAY = 10;
-exports.LOCK_RETRY_DELAY = LOCK_RETRY_DELAY;
-var MAX_NUMBER_OF_LOCK_RETRIES = 100;
-exports.MAX_NUMBER_OF_LOCK_RETRIES = MAX_NUMBER_OF_LOCK_RETRIES;
-var bufferedOperations = [];
-var ongoingOperations;
-function withCookieLockAccess(operations, numberOfRetries) {
-  if (typeof numberOfRetries === 'undefined') {
-    numberOfRetries = 0;
-  }
-  if (!ongoingOperations) {
-    ongoingOperations = operations;
-  }
-  if (operations !== ongoingOperations) {
-    bufferedOperations.push(operations);
-    return;
-  }
-  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {
-    next();
-    return;
-  }
-  var currentLock;
-  var currentSession = retrieveSession();
-  if (isCookieLockEnabled()) {
-    // if someone has lock, retry later
-    if (currentSession.lock) {
-      retryLater(operations, numberOfRetries);
-      return;
-    }
-    // acquire lock
-    currentLock = (0, _tools.UUID)();
-    currentSession.lock = currentLock;
-    setSession(currentSession, operations.options);
-    // if lock is not acquired, retry later
-    currentSession = retrieveSession();
-    if (currentSession.lock !== currentLock) {
-      retryLater(operations, numberOfRetries);
-      return;
-    }
-  }
-  var processedSession = operations.process(currentSession);
-  if (isCookieLockEnabled()) {
-    // if lock corrupted after process, retry later
-    currentSession = retrieveSession();
-    if (currentSession.lock !== currentLock) {
-      retryLater(operations, numberOfRetries);
-      return;
-    }
-  }
-  if (processedSession) {
-    persistSession(processedSession, operations.options);
-  }
-  if (isCookieLockEnabled()) {
-    // correctly handle lock around expiration would require to handle this case properly at several levels
-    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
-    if (!(processedSession && isExpiredState(processedSession))) {
-      // if lock corrupted after persist, retry later
-      currentSession = retrieveSession();
-      if (currentSession.lock !== currentLock) {
-        retryLater(operations, numberOfRetries);
-        return;
-      }
-      delete currentSession.lock;
-      setSession(currentSession, operations.options);
-      processedSession = currentSession;
-    }
-  }
-  // call after even if session is not persisted in order to perform operations on
-  // up-to-date cookie value, the value could have been modified by another tab
-  if (operations.after) {
-    operations.after(processedSession || currentSession);
-  }
-  next();
-}
-
-/**
- * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.
- * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.
- */
-function isCookieLockEnabled() {
-  return (0, _tools.isChromium)();
-}
-function retryLater(operations, currentNumberOfRetries) {
-  (0, _timer.setTimeout)(function () {
-    withCookieLockAccess(operations, currentNumberOfRetries + 1);
-  }, LOCK_RETRY_DELAY);
-}
-function next() {
-  ongoingOperations = undefined;
-  var nextOperations = bufferedOperations.shift();
-  if (nextOperations) {
-    withCookieLockAccess(nextOperations);
-  }
-}
-function persistSession(session, options) {
-  if (isExpiredState(session)) {
-    clearSession(options);
-    return;
-  }
-  session.expire = String((0, _tools.dateNow)() + _sessionConstants.SESSION_EXPIRATION_DELAY);
-  setSession(session, options);
-}
-function setSession(session, options) {
-  (0, _cookie.setCookie)(SESSION_COOKIE_NAME, toSessionString(session), _sessionConstants.SESSION_EXPIRATION_DELAY, options);
-}
-function toSessionString(session) {
-  return (0, _tools.map)((0, _tools.objectEntries)(session), function (item) {
-    return item[0] + '=' + item[1];
-  }).join(SESSION_ENTRY_SEPARATOR);
-}
-function retrieveSession() {
-  var sessionString = (0, _cookie.getCookie)(SESSION_COOKIE_NAME);
-  var session = {};
-  if (isValidSessionString(sessionString)) {
-    (0, _tools.each)(sessionString.split(SESSION_ENTRY_SEPARATOR), function (entry) {
-      var matches = SESSION_ENTRY_REGEXP.exec(entry);
-      if (matches !== null) {
-        var key = matches[1];
-        var value = matches[2];
-        session[key] = value;
-      }
-    });
-  }
-  return session;
-}
-function isValidSessionString(sessionString) {
-  return sessionString !== undefined && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));
-}
-function isExpiredState(session) {
-  return (0, _tools.isEmptyObject)(session);
-}
-function clearSession(options) {
-  (0, _cookie.setCookie)(SESSION_COOKIE_NAME, '', 0, options);
-}
-//# sourceMappingURL=sessionCookieStore.js.map

package/cjs/session/sessionCookieStore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sessionCookieStore.js","names":["_cookie","require","_tools","_sessionConstants","_timer","SESSION_ENTRY_REGEXP","SESSION_ENTRY_SEPARATOR","SESSION_COOKIE_NAME","exports","LOCK_RETRY_DELAY","MAX_NUMBER_OF_LOCK_RETRIES","bufferedOperations","ongoingOperations","withCookieLockAccess","operations","numberOfRetries","push","next","currentLock","currentSession","retrieveSession","isCookieLockEnabled","lock","retryLater","UUID","setSession","options","processedSession","process","persistSession","isExpiredState","after","isChromium","currentNumberOfRetries","setTimeout","undefined","nextOperations","shift","session","clearSession","expire","String","dateNow","SESSION_EXPIRATION_DELAY","setCookie","toSessionString","map","objectEntries","item","join","sessionString","getCookie","isValidSessionString","each","split","entry","matches","exec","key","value","indexOf","test","isEmptyObject"],"sources":["../../src/session/sessionCookieStore.js"],"sourcesContent":["import { getCookie, setCookie } from '../browser/cookie'\nimport {\n  isChromium,\n  dateNow,\n  isEmptyObject,\n  UUID,\n  objectEntries,\n  map,\n  each\n} from '../helper/tools'\nimport { SESSION_EXPIRATION_DELAY } from './sessionConstants'\nimport { setTimeout } from '../helper/timer'\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/\nvar SESSION_ENTRY_SEPARATOR = '&'\n\nexport var SESSION_COOKIE_NAME = '_dataflux_s'\n\n// arbitrary values\nexport var LOCK_RETRY_DELAY = 10\nexport var MAX_NUMBER_OF_LOCK_RETRIES = 100\n\nvar bufferedOperations = []\nvar ongoingOperations\n\nexport function withCookieLockAccess(operations, numberOfRetries) {\n  if (typeof numberOfRetries === 'undefined') {\n    numberOfRetries = 0\n  }\n  if (!ongoingOperations) {\n    ongoingOperations = operations\n  }\n  if (operations !== ongoingOperations) {\n    bufferedOperations.push(operations)\n    return\n  }\n  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {\n    next()\n    return\n  }\n  var currentLock\n  var currentSession = retrieveSession()\n  if (isCookieLockEnabled()) {\n    // if someone has lock, retry later\n    if (currentSession.lock) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n    // acquire lock\n    currentLock = UUID()\n    currentSession.lock = currentLock\n    setSession(currentSession, operations.options)\n    // if lock is not acquired, retry later\n    currentSession = retrieveSession()\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n  }\n  var processedSession = operations.process(currentSession)\n  if (isCookieLockEnabled()) {\n    // if lock corrupted after process, retry later\n    currentSession = retrieveSession()\n    if (currentSession.lock !== currentLock) {\n      retryLater(operations, numberOfRetries)\n      return\n    }\n  }\n  if (processedSession) {\n    persistSession(processedSession, operations.options)\n  }\n  if (isCookieLockEnabled()) {\n    // correctly handle lock around expiration would require to handle this case properly at several levels\n    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n    if (!(processedSession && isExpiredState(processedSession))) {\n      // if lock corrupted after persist, retry later\n      currentSession = retrieveSession()\n      if (currentSession.lock !== currentLock) {\n        retryLater(operations, numberOfRetries)\n        return\n      }\n      delete currentSession.lock\n      setSession(currentSession, operations.options)\n      processedSession = currentSession\n    }\n  }\n  // call after even if session is not persisted in order to perform operations on\n  // up-to-date cookie value, the value could have been modified by another tab\n  if (operations.after) {\n    operations.after(processedSession || currentSession)\n  }\n  next()\n}\n\n/**\n * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.\n * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.\n */\nfunction isCookieLockEnabled() {\n  return isChromium()\n}\n\nfunction retryLater(operations, currentNumberOfRetries) {\n  setTimeout(function () {\n    withCookieLockAccess(operations, currentNumberOfRetries + 1)\n  }, LOCK_RETRY_DELAY)\n}\n\nfunction next() {\n  ongoingOperations = undefined\n  var nextOperations = bufferedOperations.shift()\n  if (nextOperations) {\n    withCookieLockAccess(nextOperations)\n  }\n}\n\nexport function persistSession(session, options) {\n  if (isExpiredState(session)) {\n    clearSession(options)\n    return\n  }\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)\n  setSession(session, options)\n}\n\nfunction setSession(session, options) {\n  setCookie(\n    SESSION_COOKIE_NAME,\n    toSessionString(session),\n    SESSION_EXPIRATION_DELAY,\n    options\n  )\n}\n\nexport function toSessionString(session) {\n  return map(objectEntries(session), function (item) {\n    return item[0] + '=' + item[1]\n  }).join(SESSION_ENTRY_SEPARATOR)\n}\n\nexport function retrieveSession() {\n  var sessionString = getCookie(SESSION_COOKIE_NAME)\n  var session = {}\n  if (isValidSessionString(sessionString)) {\n    each(sessionString.split(SESSION_ENTRY_SEPARATOR), function (entry) {\n      var matches = SESSION_ENTRY_REGEXP.exec(entry)\n      if (matches !== null) {\n        var key = matches[1]\n        var value = matches[2]\n        session[key] = value\n      }\n    })\n  }\n  return session\n}\n\nfunction isValidSessionString(sessionString) {\n  return (\n    sessionString !== undefined &&\n    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 ||\n      SESSION_ENTRY_REGEXP.test(sessionString))\n  )\n}\n\nfunction isExpiredState(session) {\n  return isEmptyObject(session)\n}\nexport function clearSession(options) {\n  setCookie(SESSION_COOKIE_NAME, '', 0, options)\n}\n"],"mappings":"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","ignoreList":[]}