@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

package/esm/domain/session/sessionManager.mjs

@@ -0,0 +1,225 @@
+import { display } from "../../tools/display.mjs";
+import { generateUUID } from "../../tools/utils/stringUtils.mjs";
+import { isWorkerEnvironment } from "../../tools/globalObject.mjs";
+import { monitorError } from "../../tools/monitor.mjs";
+import { Observable } from "../../tools/observable.mjs";
+import { mockable } from "../../tools/mockable.mjs";
+import { clearInterval, clearTimeout, setInterval, setTimeout } from "../../tools/timer.mjs";
+import { noop, throttle } from "../../tools/utils/functionUtils.mjs";
+import { addEventListener, addEventListeners } from "../../browser/addEventListener.mjs";
+import { addTelemetryMetrics } from "../telemetry/telemetry.mjs";
+import { createValueHistory } from "../../tools/valueHistory.mjs";
+import { isSampled } from "../sampler.mjs";
+import { SESSION_TIME_OUT_DELAY } from "./sessionConstants.mjs";
+import { expandOnly, expandOrRenew, getCreatedDate, getExpireDate, getExpiredSessionState, initializeSession, isSessionInExpiredState } from "./sessionState.mjs";
+import { getSessionStoreStrategy, selectSessionStoreStrategyType } from "./sessionStore.mjs";
+import { ONE_HOUR, ONE_MINUTE, ONE_SECOND, clocksOrigin, dateNow, elapsed, relativeNow, timeStampNow } from "@openobserve/js-core/time";
+//#region src/domain/session/sessionManager.ts
+const VISIBILITY_CHECK_DELAY = ONE_MINUTE;
+const SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;
+const TRACKED_SESSION_MAX_AGE = ONE_HOUR * 12;
+let stopCallbacks = [];
+async function startSessionManager(configuration, trackingConsentState) {
+	const startTime = relativeNow();
+	const renewObservable = new Observable();
+	const expireObservable = new Observable();
+	const sessionStoreStrategyType = await mockable(selectSessionStoreStrategyType)(configuration);
+	if (!sessionStoreStrategyType) {
+		display.warn("No storage available for session. We will not send any data.");
+		return;
+	}
+	const strategy = mockable(getSessionStoreStrategy)(sessionStoreStrategyType, configuration);
+	const sessionContextHistory = createValueHistory({ expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY });
+	stopCallbacks.push(() => sessionContextHistory.stop());
+	let sessionExpired = false;
+	const { throttled: throttledExpandOrRenew, cancel: cancelExpandOrRenew } = throttle(() => {
+		sessionExpired = false;
+		strategy.setSessionState((state) => expandOrRenew(state, configuration), "expandOrRenewOnActivity").catch(monitorError);
+	}, ONE_SECOND);
+	stopCallbacks.push(cancelExpandOrRenew);
+	let expirationTimeoutId;
+	stopCallbacks.push(() => clearTimeout(expirationTimeoutId));
+	let stopped = false;
+	stopCallbacks.push(() => {
+		stopped = true;
+	});
+	let initialState = await resolveInitialState().catch((error) => monitorError(/* @__PURE__ */ new Error(`Error while resolving initial session state: ${error}`)));
+	if (!initialState || stopped) return;
+	while (!trackingConsentState.isGranted()) {
+		expire();
+		await new Promise((resolve) => trackingConsentState.onGrantedOnce(resolve));
+		if (stopped) return;
+		initialState = await resolveInitialState().catch(monitorError);
+		if (!initialState || stopped) return;
+	}
+	sessionContextHistory.add(buildSessionContext(initialState), clocksOrigin().relative);
+	scheduleExpirationTimeout(initialState);
+	subscribeToSessionChanges();
+	setupSessionTracking();
+	addTelemetryMetrics("Session manager init metrics", { metrics: { duration: elapsed(startTime, relativeNow()) } });
+	return buildSessionManager();
+	async function resolveInitialState() {
+		let state = {};
+		await strategy.setSessionState((currentState) => {
+			state = expandOrRenew(initializeSession(currentState, configuration), configuration);
+			return state;
+		}, "initialize");
+		return state;
+	}
+	function subscribeToSessionChanges() {
+		const subscription = strategy.sessionObservable.subscribe((sessionState) => {
+			scheduleExpirationTimeout(sessionState);
+			handleStateChange(sessionState);
+		});
+		stopCallbacks.push(() => subscription.unsubscribe());
+	}
+	function scheduleExpirationTimeout(state) {
+		clearTimeout(expirationTimeoutId);
+		const expireDate = getExpireDate(state);
+		if (expireDate) expirationTimeoutId = setTimeout(() => {
+			strategy.setSessionState((state) => {
+				if (isSessionInExpiredState(state)) {
+					if (!trackingConsentState.isGranted()) delete state.anonymousId;
+					return getExpiredSessionState(state, configuration);
+				}
+				return state;
+			}, "expireOnTimeout").catch(monitorError);
+		}, expireDate - dateNow());
+	}
+	function setupSessionTracking() {
+		trackingConsentState.observable.subscribe(() => {
+			if (trackingConsentState.isGranted()) {
+				sessionExpired = false;
+				strategy.setSessionState((state) => expandOrRenew(state, configuration), "expandOrRenewOnConsent").catch(monitorError);
+			} else expire();
+		});
+		if (!isWorkerEnvironment) {
+			trackActivity(() => {
+				if (trackingConsentState.isGranted()) throttledExpandOrRenew();
+			});
+			trackVisibility(() => {
+				if (!sessionExpired) strategy.setSessionState((state) => expandOnly(state), "expandOnVisibility").catch(monitorError);
+			});
+			trackResume(() => {
+				strategy.setSessionState((state) => initializeSession(state, configuration), "initializeOnResume").catch(monitorError);
+			});
+		}
+	}
+	function buildSessionManager() {
+		return {
+			findSession: (startTime, options) => sessionContextHistory.find(startTime, options),
+			findTrackedSession: (startTime, options) => {
+				const session = sessionContextHistory.find(startTime, options);
+				if (!session || session.id === "invalid" || !isSampled(session.id, configuration.sessionSampleRate)) return;
+				if (dateNow() - session.createdAt > TRACKED_SESSION_MAX_AGE) return;
+				return session;
+			},
+			renewObservable,
+			expireObservable,
+			expire,
+			updateSessionState: (partialState) => {
+				strategy.setSessionState((state) => ({
+					...state,
+					...partialState
+				}), "updateState").catch(monitorError);
+			}
+		};
+	}
+	function handleStateChange(newState) {
+		const previousSession = sessionContextHistory.find();
+		const hadSession = previousSession?.id !== void 0;
+		const hasSession = newState.id !== void 0;
+		const sessionIdChanged = hadSession && hasSession && previousSession.id !== newState.id;
+		if (hadSession && (!hasSession || sessionIdChanged)) {
+			sessionExpired = true;
+			expireObservable.notify();
+			sessionContextHistory.closeActive(relativeNow());
+		}
+		if (hasSession && (!hadSession || sessionIdChanged)) {
+			if (sessionExpired) return;
+			sessionContextHistory.add(buildSessionContext(newState), relativeNow());
+			renewObservable.notify();
+		} else if (hadSession && hasSession && !sessionIdChanged) previousSession.isReplayForced = !!newState.forcedReplay;
+	}
+	function expire() {
+		cancelExpandOrRenew();
+		const expiredState = getExpiredSessionState(sessionContextHistory.find(), configuration);
+		if (!trackingConsentState.isGranted()) delete expiredState.anonymousId;
+		handleStateChange(expiredState);
+		strategy.setSessionState((state) => {
+			if (!trackingConsentState.isGranted()) delete state.anonymousId;
+			return getExpiredSessionState(state, configuration);
+		}, "expire").catch(monitorError);
+	}
+	function buildSessionContext(sessionState) {
+		const createdAt = getCreatedDate(sessionState) ?? timeStampNow();
+		if (!sessionState.id) return {
+			id: "invalid",
+			isReplayForced: false,
+			anonymousId: void 0,
+			createdAt
+		};
+		return {
+			id: sessionState.id,
+			isReplayForced: !!sessionState.forcedReplay,
+			anonymousId: sessionState.anonymousId,
+			createdAt
+		};
+	}
+}
+function startSessionManagerStub() {
+	let sessionContext = {
+		id: generateUUID(),
+		isReplayForced: false,
+		anonymousId: void 0,
+		createdAt: timeStampNow()
+	};
+	return Promise.resolve({
+		findSession: () => sessionContext,
+		findTrackedSession: () => sessionContext,
+		renewObservable: new Observable(),
+		expireObservable: new Observable(),
+		expire: noop,
+		updateSessionState: (state) => {
+			sessionContext = {
+				...sessionContext,
+				...state
+			};
+		}
+	});
+}
+function stopSessionManager() {
+	stopCallbacks.forEach((e) => e());
+	stopCallbacks = [];
+}
+function trackActivity(expandOrRenewSession) {
+	const { stop } = addEventListeners(window, [
+		"click",
+		"touchstart",
+		"keydown",
+		"scroll"
+	], expandOrRenewSession, {
+		capture: true,
+		passive: true
+	});
+	stopCallbacks.push(stop);
+}
+function trackVisibility(expandSession) {
+	const expandSessionWhenVisible = () => {
+		if (document.visibilityState === "visible") expandSession();
+	};
+	const { stop } = addEventListener(document, "visibilitychange", expandSessionWhenVisible);
+	stopCallbacks.push(stop);
+	const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
+	stopCallbacks.push(() => {
+		clearInterval(visibilityCheckInterval);
+	});
+}
+function trackResume(cb) {
+	const { stop } = addEventListener(window, "resume", cb, { capture: true });
+	stopCallbacks.push(stop);
+}
+//#endregion
+export { startSessionManager, startSessionManagerStub, stopSessionManager };
+
+//# sourceMappingURL=sessionManager.mjs.map

package/esm/domain/session/sessionManager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionManager.mjs","names":[],"sources":["../../../src/domain/session/sessionManager.ts"],"sourcesContent":["import {\n  ONE_HOUR,\n  ONE_MINUTE,\n  ONE_SECOND,\n  dateNow,\n  elapsed,\n  timeStampNow,\n  clocksOrigin,\n  relativeNow,\n} from '@openobserve/js-core/time'\nimport type { TimeStamp, RelativeTime } from '@openobserve/js-core/time'\nimport { Observable } from '../../tools/observable'\nimport { createValueHistory } from '../../tools/valueHistory'\nimport { addEventListener, addEventListeners, DOM_EVENT } from '../../browser/addEventListener'\nimport { clearInterval, clearTimeout, setInterval, setTimeout } from '../../tools/timer'\nimport { mockable } from '../../tools/mockable'\nimport { noop, throttle } from '../../tools/utils/functionUtils'\nimport { generateUUID } from '../../tools/utils/stringUtils'\nimport type { Configuration } from '../configuration'\nimport type { TrackingConsentState } from '../trackingConsent'\nimport { isWorkerEnvironment } from '../../tools/globalObject'\nimport { display } from '../../tools/display'\nimport { isSampled } from '../sampler'\nimport { TelemetryMetrics, addTelemetryMetrics } from '../telemetry'\nimport { monitorError } from '../../tools/monitor'\nimport { SESSION_TIME_OUT_DELAY } from './sessionConstants'\nimport type { SessionState } from './sessionState'\nimport {\n  expandOnly,\n  expandOrRenew,\n  getCreatedDate,\n  getExpireDate,\n  getExpiredSessionState,\n  initializeSession,\n  isSessionInExpiredState,\n} from './sessionState'\nimport { getSessionStoreStrategy, selectSessionStoreStrategyType } from './sessionStore'\n\nexport interface SessionManager {\n  findSession: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => SessionContext | undefined\n  findTrackedSession: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => SessionContext | undefined\n  renewObservable: Observable<void>\n  expireObservable: Observable<void>\n  expire: () => void\n  updateSessionState: (state: Partial<SessionState>) => void\n}\n\nexport interface SessionContext {\n  id: string\n  anonymousId?: string | undefined\n  isReplayForced?: boolean\n  createdAt: TimeStamp\n}\n\nexport const VISIBILITY_CHECK_DELAY = ONE_MINUTE\nconst SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY\n\n// Maximum duration for which we can send data related to a session.\n//\n// The backend behavior depends on how old the session is when it receives an event:\n// - Session started < 4h ago: the backend updates the session normally.\n// - Session started between 4h and 24h ago: the backend ignores the event (safe).\n// - Session started > 24h ago: the backend recreates a session with that id (problematic).\n//\n// We choose 12h as a threshold — safely between 4h and 24h — to avoid both recreating\n// sessions and discarding too many legitimate late events.\nexport const TRACKED_SESSION_MAX_AGE = ONE_HOUR * 12\nlet stopCallbacks: Array<() => void> = []\n\nexport async function startSessionManager(\n  configuration: Configuration,\n  trackingConsentState: TrackingConsentState\n): Promise<SessionManager | undefined> {\n  const startTime = relativeNow()\n  const renewObservable = new Observable<void>()\n  const expireObservable = new Observable<void>()\n\n  const sessionStoreStrategyType = await mockable(selectSessionStoreStrategyType)(configuration)\n  if (!sessionStoreStrategyType) {\n    display.warn('No storage available for session. We will not send any data.')\n    return\n  }\n\n  const strategy = mockable(getSessionStoreStrategy)(sessionStoreStrategyType, configuration)\n\n  const sessionContextHistory = createValueHistory<SessionContext>({\n    expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,\n  })\n  stopCallbacks.push(() => sessionContextHistory.stop())\n\n  let sessionExpired = false\n\n  const { throttled: throttledExpandOrRenew, cancel: cancelExpandOrRenew } = throttle(() => {\n    sessionExpired = false\n    strategy\n      .setSessionState((state) => expandOrRenew(state, configuration), 'expandOrRenewOnActivity')\n      .catch(monitorError)\n  }, ONE_SECOND)\n  stopCallbacks.push(cancelExpandOrRenew)\n\n  let expirationTimeoutId: ReturnType<typeof setTimeout> | undefined\n  stopCallbacks.push(() => clearTimeout(expirationTimeoutId))\n\n  let stopped = false\n  stopCallbacks.push(() => {\n    stopped = true\n  })\n\n  let initialState = await resolveInitialState().catch((error) =>\n    monitorError(new Error(`Error while resolving initial session state: ${error}`))\n  )\n  if (!initialState || stopped) {\n    return\n  }\n\n  // Consent is always granted when the session manager is started, but it may\n  // be revoked during the async initialization (e.g., while waiting for cookie lock).\n  // Mirror setupSessionTracking's revoke/grant handler until the manager is installed:\n  // expire the session in storage, wait for the next grant, then re-resolve.\n  while (!trackingConsentState.isGranted()) {\n    expire()\n    await new Promise<void>((resolve) => trackingConsentState.onGrantedOnce(resolve))\n    if (stopped) {\n      return\n    }\n    initialState = await resolveInitialState().catch(monitorError)\n    if (!initialState || stopped) {\n      return\n    }\n  }\n\n  sessionContextHistory.add(buildSessionContext(initialState), clocksOrigin().relative)\n  scheduleExpirationTimeout(initialState)\n  subscribeToSessionChanges()\n  setupSessionTracking()\n\n  // monitor-until: 2026-10-15\n  addTelemetryMetrics(TelemetryMetrics.SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME, {\n    metrics: { duration: elapsed(startTime, relativeNow()) },\n  })\n\n  return buildSessionManager()\n\n  async function resolveInitialState() {\n    let state: SessionState = {}\n    await strategy.setSessionState((currentState) => {\n      const initialState = initializeSession(currentState, configuration)\n      state = expandOrRenew(initialState, configuration)\n      return state\n    }, 'initialize')\n    return state\n  }\n\n  function subscribeToSessionChanges() {\n    const subscription = strategy.sessionObservable.subscribe((sessionState) => {\n      scheduleExpirationTimeout(sessionState)\n      handleStateChange(sessionState)\n    })\n    stopCallbacks.push(() => subscription.unsubscribe())\n  }\n\n  function scheduleExpirationTimeout(state: SessionState) {\n    clearTimeout(expirationTimeoutId)\n    const expireDate = getExpireDate(state)\n    if (expireDate) {\n      const delay = expireDate - dateNow()\n      expirationTimeoutId = setTimeout(() => {\n        strategy\n          .setSessionState((state) => {\n            if (isSessionInExpiredState(state)) {\n              if (!trackingConsentState.isGranted()) {\n                delete state.anonymousId\n              }\n\n              return getExpiredSessionState(state, configuration)\n            }\n\n            return state\n          }, 'expireOnTimeout')\n          .catch(monitorError)\n      }, delay)\n    }\n  }\n\n  function setupSessionTracking() {\n    trackingConsentState.observable.subscribe(() => {\n      if (trackingConsentState.isGranted()) {\n        sessionExpired = false\n        strategy\n          .setSessionState((state) => expandOrRenew(state, configuration), 'expandOrRenewOnConsent')\n          .catch(monitorError)\n      } else {\n        expire()\n      }\n    })\n\n    if (!isWorkerEnvironment) {\n      trackActivity(() => {\n        if (trackingConsentState.isGranted()) {\n          throttledExpandOrRenew()\n        }\n      })\n      trackVisibility(() => {\n        if (!sessionExpired) {\n          strategy.setSessionState((state) => expandOnly(state), 'expandOnVisibility').catch(monitorError)\n        }\n      })\n      trackResume(() => {\n        strategy\n          .setSessionState((state) => initializeSession(state, configuration), 'initializeOnResume')\n          .catch(monitorError)\n      })\n    }\n  }\n\n  function buildSessionManager(): SessionManager {\n    return {\n      findSession: (startTime, options) => sessionContextHistory.find(startTime, options),\n      findTrackedSession: (startTime, options) => {\n        const session = sessionContextHistory.find(startTime, options)\n\n        if (!session || session.id === 'invalid' || !isSampled(session.id, configuration.sessionSampleRate)) {\n          return\n        }\n\n        if (dateNow() - session.createdAt > TRACKED_SESSION_MAX_AGE) {\n          return\n        }\n\n        return session\n      },\n      renewObservable,\n      expireObservable,\n      expire,\n      updateSessionState: (partialState) => {\n        strategy.setSessionState((state) => ({ ...state, ...partialState }), 'updateState').catch(monitorError)\n      },\n    }\n  }\n\n  function handleStateChange(newState: SessionState) {\n    const previousSession = sessionContextHistory.find()\n    const hadSession = previousSession?.id !== undefined\n    const hasSession = newState.id !== undefined\n    const sessionIdChanged = hadSession && hasSession && previousSession.id !== newState.id\n\n    if (hadSession && (!hasSession || sessionIdChanged)) {\n      // Session expired or replaced\n      sessionExpired = true\n      expireObservable.notify()\n      sessionContextHistory.closeActive(relativeNow())\n    }\n\n    if (hasSession && (!hadSession || sessionIdChanged)) {\n      if (sessionExpired) {\n        // Don't adopt another tab's session — this tab needs its own user interaction to renew\n        return\n      }\n      // New session appeared\n      sessionContextHistory.add(buildSessionContext(newState), relativeNow())\n      renewObservable.notify()\n    } else if (hadSession && hasSession && !sessionIdChanged) {\n      // Same session,\n      // Mutate the session context in the history for replay forced changes\n\n      previousSession.isReplayForced = !!newState.forcedReplay\n    }\n  }\n\n  function expire() {\n    cancelExpandOrRenew()\n    // Update in-memory state synchronously so events stop being collected immediately\n    const expiredState = getExpiredSessionState(sessionContextHistory.find(), configuration)\n    if (!trackingConsentState.isGranted()) {\n      delete expiredState.anonymousId\n    }\n    handleStateChange(expiredState)\n    // Persist to storage asynchronously\n    strategy\n      .setSessionState((state) => {\n        if (!trackingConsentState.isGranted()) {\n          delete state.anonymousId\n        }\n        return getExpiredSessionState(state, configuration)\n      }, 'expire')\n      .catch(monitorError)\n  }\n\n  function buildSessionContext(sessionState: SessionState): SessionContext {\n    const createdAt = getCreatedDate(sessionState) ?? timeStampNow()\n\n    if (!sessionState.id) {\n      return {\n        id: 'invalid',\n        isReplayForced: false,\n        anonymousId: undefined,\n        createdAt,\n      }\n    }\n\n    return {\n      id: sessionState.id,\n      isReplayForced: !!sessionState.forcedReplay,\n      anonymousId: sessionState.anonymousId,\n      createdAt,\n    }\n  }\n}\n\nexport function startSessionManagerStub(): Promise<SessionManager> {\n  const stubSessionId = generateUUID()\n  let sessionContext: SessionContext = {\n    id: stubSessionId,\n    isReplayForced: false,\n    anonymousId: undefined,\n    createdAt: timeStampNow(),\n  }\n  return Promise.resolve({\n    findSession: () => sessionContext,\n    findTrackedSession: () => sessionContext,\n    renewObservable: new Observable(),\n    expireObservable: new Observable(),\n    expire: noop,\n    updateSessionState: (state) => {\n      sessionContext = {\n        ...sessionContext,\n        ...state,\n      }\n    },\n  })\n}\n\nexport function stopSessionManager() {\n  stopCallbacks.forEach((e) => e())\n  stopCallbacks = []\n}\n\nfunction trackActivity(expandOrRenewSession: () => void) {\n  const { stop } = addEventListeners(\n    window,\n    [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],\n    expandOrRenewSession,\n    { capture: true, passive: true }\n  )\n  stopCallbacks.push(stop)\n}\n\nfunction trackVisibility(expandSession: () => void) {\n  const expandSessionWhenVisible = () => {\n    if (document.visibilityState === 'visible') {\n      expandSession()\n    }\n  }\n\n  const { stop } = addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)\n  stopCallbacks.push(stop)\n\n  const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)\n  stopCallbacks.push(() => {\n    clearInterval(visibilityCheckInterval)\n  })\n}\n\nfunction trackResume(cb: () => void) {\n  const { stop } = addEventListener(window, DOM_EVENT.RESUME, cb, { capture: true })\n  stopCallbacks.push(stop)\n}\n"],"mappings":"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"}

package/esm/domain/session/sessionState.mjs

@@ -0,0 +1,76 @@
+import { isEmptyObject } from "../../tools/utils/objectUtils.mjs";
+import { generateUUID } from "../../tools/utils/stringUtils.mjs";
+import { objectEntries } from "../../tools/utils/polyfills.mjs";
+import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from "./sessionConstants.mjs";
+import { SESSION_ENTRY_REGEXP, isValidSessionString } from "./sessionStateValidation.mjs";
+import { dateNow } from "@openobserve/js-core/time";
+function getCreatedDate(state) {
+	return state.created ? Number(state.created) : void 0;
+}
+function getExpireDate(state) {
+	const expireDate = state.expire && Number(state.expire);
+	const createdDate = getCreatedDate(state);
+	if (expireDate && createdDate) return Math.min(expireDate, createdDate + SESSION_TIME_OUT_DELAY);
+}
+function getExpiredSessionState(previousSessionState, configuration) {
+	const expiredSessionState = { isExpired: "1" };
+	if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) expiredSessionState.anonymousId = previousSessionState?.anonymousId;
+	return expiredSessionState;
+}
+function isSessionInNotStartedState(session) {
+	return isEmptyObject(session);
+}
+function isSessionInExpiredState(session) {
+	return session.isExpired !== void 0 || !isActiveSession(session);
+}
+function isActiveSession(sessionState) {
+	const expireDate = getExpireDate(sessionState);
+	return expireDate ? dateNow() < expireDate : false;
+}
+function expandSessionState(session) {
+	session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY);
+}
+function toSessionString(session) {
+	return objectEntries(session).map(([key, value]) => key === "anonymousId" ? `aid=${value}` : `${key}=${value}`).join("&");
+}
+function toSessionState(sessionString) {
+	const session = {};
+	if (isValidSessionString(sessionString)) sessionString.split("&").forEach((entry) => {
+		const matches = SESSION_ENTRY_REGEXP.exec(entry);
+		if (matches !== null) {
+			const [, key, value] = matches;
+			if (key === "aid") session.anonymousId = value;
+			else session[key] = value;
+		}
+	});
+	return session;
+}
+function initializeSession(state, configuration) {
+	if (isSessionInNotStartedState(state)) {
+		if (configuration.trackAnonymousUser) state.anonymousId = generateUUID();
+		return getExpiredSessionState(state, configuration);
+	}
+	return state;
+}
+function expandOrRenew(state, configuration) {
+	if (isSessionInNotStartedState(state)) return state;
+	let newState = state;
+	if (isSessionInExpiredState(state)) newState = getExpiredSessionState(state, configuration);
+	if (!newState.id) {
+		newState.id = generateUUID();
+		newState.created = String(dateNow());
+	}
+	if (configuration.trackAnonymousUser && !newState.anonymousId) newState.anonymousId = generateUUID();
+	delete newState.isExpired;
+	expandSessionState(newState);
+	return newState;
+}
+function expandOnly(state) {
+	if (isSessionInExpiredState(state) || isSessionInNotStartedState(state) || !state.id) return state;
+	expandSessionState(state);
+	return state;
+}
+//#endregion
+export { expandOnly, expandOrRenew, getCreatedDate, getExpireDate, getExpiredSessionState, initializeSession, isSessionInExpiredState, isSessionInNotStartedState, toSessionState, toSessionString };
+
+//# sourceMappingURL=sessionState.mjs.map

package/esm/domain/session/sessionState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionState.mjs","names":[],"sources":["../../../src/domain/session/sessionState.ts"],"sourcesContent":["import { dateNow } from '@openobserve/js-core/time'\nimport type { TimeStamp } from '@openobserve/js-core/time'\nimport { isEmptyObject } from '../../tools/utils/objectUtils'\nimport { objectEntries } from '../../tools/utils/polyfills'\nimport { generateUUID } from '../../tools/utils/stringUtils'\nimport type { Configuration } from '../configuration'\nimport { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'\nimport { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'\nexport const EXPIRED = '1'\n\nexport interface SessionState {\n  id?: string\n  created?: string\n  expire?: string\n  isExpired?: typeof EXPIRED\n  anonymousId?: string\n\n  [key: string]: string | undefined\n}\n\nexport function getCreatedDate(state: SessionState): TimeStamp | undefined {\n  return state.created ? (Number(state.created) as TimeStamp) : undefined\n}\n\nexport function getExpireDate(state: SessionState): TimeStamp | undefined {\n  const expireDate = state.expire && (Number(state.expire) as TimeStamp)\n  const createdDate = getCreatedDate(state)\n  if (expireDate && createdDate) {\n    return Math.min(expireDate, createdDate + SESSION_TIME_OUT_DELAY) as TimeStamp\n  }\n}\n\nexport function getExpiredSessionState(\n  previousSessionState: { anonymousId?: string } | undefined,\n  configuration: Configuration\n): SessionState {\n  const expiredSessionState: SessionState = {\n    isExpired: EXPIRED,\n  }\n  if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) {\n    expiredSessionState.anonymousId = previousSessionState?.anonymousId\n  }\n\n  return expiredSessionState\n}\n\nexport function isSessionInNotStartedState(session: SessionState) {\n  return isEmptyObject(session)\n}\n\nexport function isSessionStarted(session: SessionState) {\n  return !isSessionInNotStartedState(session)\n}\n\nexport function isSessionInExpiredState(session: SessionState) {\n  return session.isExpired !== undefined || !isActiveSession(session)\n}\n\n// An active session is a session in either `Tracked` or `NotTracked` state\nfunction isActiveSession(sessionState: SessionState) {\n  const expireDate = getExpireDate(sessionState)\n  return expireDate ? dateNow() < expireDate : false\n}\n\nexport function expandSessionState(session: SessionState) {\n  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)\n}\n\nexport function toSessionString(session: SessionState) {\n  return (\n    objectEntries(session)\n      // we use `aid` as a key for anonymousId\n      .map(([key, value]) => (key === 'anonymousId' ? `aid=${value}` : `${key}=${value}`))\n      .join(SESSION_ENTRY_SEPARATOR)\n  )\n}\n\nexport function toSessionState(sessionString: string | undefined | null) {\n  const session: SessionState = {}\n  if (isValidSessionString(sessionString)) {\n    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach((entry) => {\n      const matches = SESSION_ENTRY_REGEXP.exec(entry)\n      if (matches !== null) {\n        const [, key, value] = matches\n        if (key === 'aid') {\n          // we use `aid` as a key for anonymousId\n          session.anonymousId = value\n        } else {\n          session[key] = value\n        }\n      }\n    })\n  }\n  return session\n}\n\nexport function initializeSession(state: SessionState, configuration: Configuration): SessionState {\n  if (isSessionInNotStartedState(state)) {\n    if (configuration.trackAnonymousUser) {\n      state.anonymousId = generateUUID()\n    }\n    return getExpiredSessionState(state, configuration)\n  }\n  return state\n}\n\nexport function expandOrRenew(state: SessionState, configuration: Configuration): SessionState {\n  // prevent renewing if state is altered by a 3rd party (e.g. adblocker deleting the cookie)\n  if (isSessionInNotStartedState(state)) {\n    return state\n  }\n\n  let newState = state\n\n  if (isSessionInExpiredState(state)) {\n    newState = getExpiredSessionState(state, configuration)\n  }\n\n  if (!newState.id) {\n    newState.id = generateUUID()\n    newState.created = String(dateNow())\n  }\n  if (configuration.trackAnonymousUser && !newState.anonymousId) {\n    newState.anonymousId = generateUUID()\n  }\n\n  delete newState.isExpired\n  expandSessionState(newState)\n\n  return newState\n}\n\nexport function expandOnly(state: SessionState): SessionState {\n  if (isSessionInExpiredState(state) || isSessionInNotStartedState(state) || !state.id) {\n    return state\n  }\n  expandSessionState(state)\n  return state\n}\n"],"mappings":";;;;;;AAoBA,SAAgB,eAAe,OAA4C;CACzE,OAAO,MAAM,UAAW,OAAO,MAAM,OAAO,IAAkB,KAAA;AAChE;AAEA,SAAgB,cAAc,OAA4C;CACxE,MAAM,aAAa,MAAM,UAAW,OAAO,MAAM,MAAM;CACvD,MAAM,cAAc,eAAe,KAAK;CACxC,IAAI,cAAc,aAChB,OAAO,KAAK,IAAI,YAAY,cAAc,sBAAsB;AAEpE;AAEA,SAAgB,uBACd,sBACA,eACc;CACd,MAAM,sBAAoC,EACxC,WAAA,IACF;CACA,IAAI,cAAc,sBAAsB,sBAAsB,aAC5D,oBAAoB,cAAc,sBAAsB;CAG1D,OAAO;AACT;AAEA,SAAgB,2BAA2B,SAAuB;CAChE,OAAO,cAAc,OAAO;AAC9B;AAMA,SAAgB,wBAAwB,SAAuB;CAC7D,OAAO,QAAQ,cAAc,KAAA,KAAa,CAAC,gBAAgB,OAAO;AACpE;AAGA,SAAS,gBAAgB,cAA4B;CACnD,MAAM,aAAa,cAAc,YAAY;CAC7C,OAAO,aAAa,QAAQ,IAAI,aAAa;AAC/C;AAEA,SAAgB,mBAAmB,SAAuB;CACxD,QAAQ,SAAS,OAAO,QAAQ,IAAI,wBAAwB;AAC9D;AAEA,SAAgB,gBAAgB,SAAuB;CACrD,OACE,cAAc,OAAO,CAAC,CAEnB,KAAK,CAAC,KAAK,WAAY,QAAQ,gBAAgB,OAAO,UAAU,GAAG,IAAI,GAAG,OAAQ,CAAC,CACnF,KAAA,GAA4B;AAEnC;AAEA,SAAgB,eAAe,eAA0C;CACvE,MAAM,UAAwB,CAAC;CAC/B,IAAI,qBAAqB,aAAa,GACpC,cAAc,MAAA,GAA6B,CAAC,CAAC,SAAS,UAAU;EAC9D,MAAM,UAAU,qBAAqB,KAAK,KAAK;EAC/C,IAAI,YAAY,MAAM;GACpB,MAAM,GAAG,KAAK,SAAS;GACvB,IAAI,QAAQ,OAEV,QAAQ,cAAc;QAEtB,QAAQ,OAAO;EAEnB;CACF,CAAC;CAEH,OAAO;AACT;AAEA,SAAgB,kBAAkB,OAAqB,eAA4C;CACjG,IAAI,2BAA2B,KAAK,GAAG;EACrC,IAAI,cAAc,oBAChB,MAAM,cAAc,aAAa;EAEnC,OAAO,uBAAuB,OAAO,aAAa;CACpD;CACA,OAAO;AACT;AAEA,SAAgB,cAAc,OAAqB,eAA4C;CAE7F,IAAI,2BAA2B,KAAK,GAClC,OAAO;CAGT,IAAI,WAAW;CAEf,IAAI,wBAAwB,KAAK,GAC/B,WAAW,uBAAuB,OAAO,aAAa;CAGxD,IAAI,CAAC,SAAS,IAAI;EAChB,SAAS,KAAK,aAAa;EAC3B,SAAS,UAAU,OAAO,QAAQ,CAAC;CACrC;CACA,IAAI,cAAc,sBAAsB,CAAC,SAAS,aAChD,SAAS,cAAc,aAAa;CAGtC,OAAO,SAAS;CAChB,mBAAmB,QAAQ;CAE3B,OAAO;AACT;AAEA,SAAgB,WAAW,OAAmC;CAC5D,IAAI,wBAAwB,KAAK,KAAK,2BAA2B,KAAK,KAAK,CAAC,MAAM,IAChF,OAAO;CAET,mBAAmB,KAAK;CACxB,OAAO;AACT"}

package/esm/domain/session/sessionStateValidation.mjs

@@ -0,0 +1,9 @@
+//#region src/domain/session/sessionStateValidation.ts
+const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/;
+function isValidSessionString(sessionString) {
+	return !!sessionString && (sessionString.indexOf("&") !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));
+}
+//#endregion
+export { SESSION_ENTRY_REGEXP, isValidSessionString };
+
+//# sourceMappingURL=sessionStateValidation.mjs.map

package/esm/domain/session/sessionStateValidation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStateValidation.mjs","names":[],"sources":["../../../src/domain/session/sessionStateValidation.ts"],"sourcesContent":["export const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/\nexport const SESSION_ENTRY_SEPARATOR = '&'\n\nexport function isValidSessionString(sessionString: string | undefined | null): sessionString is string {\n  return (\n    !!sessionString &&\n    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))\n  )\n}\n"],"mappings":";AAAA,MAAa,uBAAuB;AAGpC,SAAgB,qBAAqB,eAAmE;CACtG,OACE,CAAC,CAAC,kBACD,cAAc,QAAA,GAA+B,MAAM,MAAM,qBAAqB,KAAK,aAAa;AAErG"}

package/esm/domain/session/sessionStore.mjs

@@ -0,0 +1,46 @@
+import { display } from "../../tools/display.mjs";
+import { isWorkerEnvironment } from "../../tools/globalObject.mjs";
+import { SessionPersistence } from "./sessionConstants.mjs";
+import { initCookieStrategy, selectCookieStrategy } from "./storeStrategies/sessionInCookie.mjs";
+import { initLocalStorageStrategy, selectLocalStorageStrategy } from "./storeStrategies/sessionInLocalStorage.mjs";
+import { initMemorySessionStoreStrategy, selectMemorySessionStoreStrategy } from "./storeStrategies/sessionInMemory.mjs";
+//#region src/domain/session/sessionStore.ts
+/**
+* Selects the correct session store strategy type based on the configuration and storage
+* availability. When an array is provided, tries each persistence type in order until one
+* successfully initializes.
+*/
+async function selectSessionStoreStrategyType(configuration) {
+	const persistenceList = normalizePersistenceList(configuration.sessionPersistence);
+	for (const persistence of persistenceList) {
+		const strategyType = await selectStrategyForPersistence(persistence, configuration);
+		if (strategyType !== void 0) return strategyType;
+	}
+}
+function normalizePersistenceList(sessionPersistence) {
+	if (Array.isArray(sessionPersistence)) return sessionPersistence;
+	if (sessionPersistence !== void 0) return [sessionPersistence];
+	if (isWorkerEnvironment) return [SessionPersistence.MEMORY];
+	return [SessionPersistence.COOKIE];
+}
+function selectStrategyForPersistence(persistence, configuration) {
+	switch (persistence) {
+		case SessionPersistence.COOKIE: return selectCookieStrategy(configuration);
+		case SessionPersistence.LOCAL_STORAGE: return selectLocalStorageStrategy();
+		case SessionPersistence.MEMORY: return selectMemorySessionStoreStrategy();
+		default:
+			display.error(`Invalid session persistence '${String(persistence)}'`);
+			return;
+	}
+}
+function getSessionStoreStrategy(sessionStoreStrategyType, configuration) {
+	switch (sessionStoreStrategyType.type) {
+		case SessionPersistence.COOKIE: return initCookieStrategy(sessionStoreStrategyType, configuration);
+		case SessionPersistence.LOCAL_STORAGE: return initLocalStorageStrategy();
+		case SessionPersistence.MEMORY: return initMemorySessionStoreStrategy();
+	}
+}
+//#endregion
+export { getSessionStoreStrategy, selectSessionStoreStrategyType };
+
+//# sourceMappingURL=sessionStore.mjs.map

package/esm/domain/session/sessionStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStore.mjs","names":[],"sources":["../../../src/domain/session/sessionStore.ts"],"sourcesContent":["import type { Configuration } from '../configuration'\nimport { isWorkerEnvironment } from '../../tools/globalObject'\nimport { display } from '../../tools/display'\nimport { SessionPersistence } from './sessionConstants'\nimport type { SessionStoreStrategy, SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'\nimport { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'\nimport { selectLocalStorageStrategy, initLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'\nimport { selectMemorySessionStoreStrategy, initMemorySessionStoreStrategy } from './storeStrategies/sessionInMemory'\n\n/**\n * Selects the correct session store strategy type based on the configuration and storage\n * availability. When an array is provided, tries each persistence type in order until one\n * successfully initializes.\n */\nexport async function selectSessionStoreStrategyType(\n  configuration: Configuration\n): Promise<SessionStoreStrategyType | undefined> {\n  const persistenceList = normalizePersistenceList(configuration.sessionPersistence)\n\n  for (const persistence of persistenceList) {\n    const strategyType = await selectStrategyForPersistence(persistence, configuration)\n    if (strategyType !== undefined) {\n      return strategyType\n    }\n  }\n\n  return undefined\n}\n\nfunction normalizePersistenceList(\n  sessionPersistence: SessionPersistence | SessionPersistence[] | undefined\n): SessionPersistence[] {\n  if (Array.isArray(sessionPersistence)) {\n    return sessionPersistence\n  }\n  if (sessionPersistence !== undefined) {\n    return [sessionPersistence]\n  }\n\n  // In worker environments, default to memory since cookie and localStorage are not available\n  // TODO: make it work when we start using Cookie Store API\n  // @see https://developer.mozilla.org/en-US/docs/Web/API/CookieStore\n  if (isWorkerEnvironment) {\n    return [SessionPersistence.MEMORY]\n  }\n\n  return [SessionPersistence.COOKIE]\n}\n\nfunction selectStrategyForPersistence(\n  persistence: SessionPersistence,\n  configuration: Configuration\n): Promise<SessionStoreStrategyType | undefined> | SessionStoreStrategyType | undefined {\n  switch (persistence) {\n    case SessionPersistence.COOKIE:\n      return selectCookieStrategy(configuration)\n\n    case SessionPersistence.LOCAL_STORAGE:\n      return selectLocalStorageStrategy()\n\n    case SessionPersistence.MEMORY:\n      return selectMemorySessionStoreStrategy()\n\n    default:\n      display.error(`Invalid session persistence '${String(persistence)}'`)\n      return undefined\n  }\n}\n\nexport function getSessionStoreStrategy(\n  sessionStoreStrategyType: SessionStoreStrategyType,\n  configuration: Configuration\n): SessionStoreStrategy {\n  switch (sessionStoreStrategyType.type) {\n    case SessionPersistence.COOKIE:\n      return initCookieStrategy(sessionStoreStrategyType, configuration)\n    case SessionPersistence.LOCAL_STORAGE:\n      return initLocalStorageStrategy()\n    case SessionPersistence.MEMORY:\n      return initMemorySessionStoreStrategy()\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,eAAsB,+BACpB,eAC+C;CAC/C,MAAM,kBAAkB,yBAAyB,cAAc,kBAAkB;CAEjF,KAAK,MAAM,eAAe,iBAAiB;EACzC,MAAM,eAAe,MAAM,6BAA6B,aAAa,aAAa;EAClF,IAAI,iBAAiB,KAAA,GACnB,OAAO;CAEX;AAGF;AAEA,SAAS,yBACP,oBACsB;CACtB,IAAI,MAAM,QAAQ,kBAAkB,GAClC,OAAO;CAET,IAAI,uBAAuB,KAAA,GACzB,OAAO,CAAC,kBAAkB;CAM5B,IAAI,qBACF,OAAO,CAAC,mBAAmB,MAAM;CAGnC,OAAO,CAAC,mBAAmB,MAAM;AACnC;AAEA,SAAS,6BACP,aACA,eACsF;CACtF,QAAQ,aAAR;EACE,KAAK,mBAAmB,QACtB,OAAO,qBAAqB,aAAa;EAE3C,KAAK,mBAAmB,eACtB,OAAO,2BAA2B;EAEpC,KAAK,mBAAmB,QACtB,OAAO,iCAAiC;EAE1C;GACE,QAAQ,MAAM,gCAAgC,OAAO,WAAW,EAAE,EAAE;GACpE;CACJ;AACF;AAEA,SAAgB,wBACd,0BACA,eACsB;CACtB,QAAQ,yBAAyB,MAAjC;EACE,KAAK,mBAAmB,QACtB,OAAO,mBAAmB,0BAA0B,aAAa;EACnE,KAAK,mBAAmB,eACtB,OAAO,yBAAyB;EAClC,KAAK,mBAAmB,QACtB,OAAO,+BAA+B;CAC1C;AACF"}

package/esm/domain/session/storeStrategies/sessionInCookie.mjs

@@ -0,0 +1,97 @@
+import { isEmptyObject } from "../../../tools/utils/objectUtils.mjs";
+import { getCookies } from "../../../browser/cookie.mjs";
+import { monitorError } from "../../../tools/monitor.mjs";
+import { Observable } from "../../../tools/observable.mjs";
+import { mockable } from "../../../tools/mockable.mjs";
+import { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY, SessionPersistence } from "../sessionConstants.mjs";
+import { toSessionState, toSessionString } from "../sessionState.mjs";
+import { areCookiesAuthorized, createCookieStoreAccess, createDocumentCookieAccess, isCookieStoreSupported } from "../../../browser/cookieAccess.mjs";
+import { LEGACY_SESSION_STORE_KEY, SESSION_STORE_KEY } from "./sessionStoreStrategy.mjs";
+//#region src/domain/session/storeStrategies/sessionInCookie.ts
+const SESSION_COOKIE_VERSION = 0;
+async function selectCookieStrategy(configuration) {
+	const { cookieOptions } = configuration;
+	if (!cookieOptions) return;
+	if (isCookieStoreSupported() && await areCookiesAuthorized(createCookieStoreAccess, cookieOptions)) return {
+		type: SessionPersistence.COOKIE,
+		cookieOptions,
+		cookieApi: 1
+	};
+	if (await areCookiesAuthorized(createDocumentCookieAccess, cookieOptions)) return {
+		type: SessionPersistence.COOKIE,
+		cookieOptions,
+		cookieApi: 0
+	};
+}
+let pendingChain;
+function initCookieStrategy(sessionStoreStrategyType, configuration) {
+	const { cookieOptions, cookieApi } = sessionStoreStrategyType;
+	const sessionObservable = new Observable();
+	const trackAnonymousUser = !!configuration.trackAnonymousUser;
+	const opts = encodeCookieOptions(cookieOptions);
+	const cookieAccess = mockable(createCookieAccess)(cookieApi, cookieOptions);
+	let isFirstCall = true;
+	cookieAccess.observable.subscribe(() => {
+		cookieAccess.getAll().then((cookieValues) => {
+			sessionObservable.notify(findMatchingSessionState(cookieValues, opts));
+		}).catch((error) => monitorError(/* @__PURE__ */ new Error(`Error while reading session cookies on change: ${error}`)));
+	});
+	function applyAndWrite(fn) {
+		return cookieAccess.getAllAndSet((cookieValues) => {
+			let currentState = findMatchingSessionState(cookieValues, opts);
+			if (isFirstCall && isEmptyObject(currentState)) currentState = findMatchingSessionState(getCookies(LEGACY_SESSION_STORE_KEY), opts);
+			isFirstCall = false;
+			return {
+				value: buildSessionString(fn(currentState), cookieOptions),
+				expireDelay: trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY
+			};
+		});
+	}
+	return {
+		async setSessionState(fn, _operation) {
+			if (typeof navigator !== "undefined" && navigator.locks) await navigator.locks.request(SESSION_STORE_KEY, () => applyAndWrite(fn)).catch((error) => {
+				if (isContextGoingAwayError(error)) return;
+				throw error;
+			});
+			else {
+				pendingChain = (pendingChain ?? Promise.resolve()).then(() => applyAndWrite(fn));
+				await pendingChain;
+			}
+		},
+		sessionObservable
+	};
+}
+function isContextGoingAwayError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.name === "AbortError" || error.message.includes("no longer runnable");
+}
+function createCookieAccess(cookieApi, cookieOptions) {
+	return cookieApi === 1 ? createCookieStoreAccess(SESSION_STORE_KEY, cookieOptions) : createDocumentCookieAccess(SESSION_STORE_KEY, cookieOptions);
+}
+function findMatchingSessionState(items, opts) {
+	let sessionState;
+	for (const item of items.slice().reverse()) {
+		sessionState = toSessionState(item);
+		if (sessionState.c === opts) break;
+	}
+	delete sessionState?.c;
+	return sessionState ?? {};
+}
+function buildSessionString(sessionState, cookieOptions) {
+	return toSessionString(isEmptyObject(sessionState) ? sessionState : {
+		...sessionState,
+		c: encodeCookieOptions(cookieOptions)
+	});
+}
+function encodeCookieOptions(cookieOptions) {
+	const domainCount = cookieOptions.domain ? cookieOptions.domain.split(".").length - 1 : 0;
+	let byte = 0;
+	byte |= SESSION_COOKIE_VERSION << 5;
+	byte |= domainCount << 1;
+	byte |= cookieOptions.crossSite ? 1 : 0;
+	return byte.toString(16);
+}
+//#endregion
+export { initCookieStrategy, selectCookieStrategy };
+
+//# sourceMappingURL=sessionInCookie.mjs.map

package/esm/domain/session/storeStrategies/sessionInCookie.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionInCookie.mjs","names":[],"sources":["../../../../src/domain/session/storeStrategies/sessionInCookie.ts"],"sourcesContent":["import { isEmptyObject } from '../../../tools/utils/objectUtils'\nimport type { CookieOptions } from '../../../browser/cookie'\nimport { getCookies } from '../../../browser/cookie'\nimport type { Configuration } from '../../configuration'\nimport { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY, SessionPersistence } from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\nimport { toSessionString, toSessionState } from '../sessionState'\nimport { Observable } from '../../../tools/observable'\nimport { mockable } from '../../../tools/mockable'\nimport { monitorError } from '../../../tools/monitor'\nimport type { CookieAccess } from '../../../browser/cookieAccess'\nimport {\n  areCookiesAuthorized,\n  createCookieStoreAccess,\n  createDocumentCookieAccess,\n  isCookieStoreSupported,\n} from '../../../browser/cookieAccess'\nimport { CookieApi, LEGACY_SESSION_STORE_KEY, SESSION_STORE_KEY } from './sessionStoreStrategy'\nimport type {\n  SessionStoreStrategy,\n  SessionStoreStrategyType,\n  CookieSessionStoreStrategyType,\n  SessionStateOperation,\n} from './sessionStoreStrategy'\n\nconst SESSION_COOKIE_VERSION = 0\n\nexport async function selectCookieStrategy(\n  configuration: Configuration\n): Promise<SessionStoreStrategyType | undefined> {\n  const { cookieOptions } = configuration\n  if (!cookieOptions) {\n    return undefined\n  }\n\n  if (isCookieStoreSupported() && (await areCookiesAuthorized(createCookieStoreAccess, cookieOptions))) {\n    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.COOKIE_STORE }\n  }\n\n  if (await areCookiesAuthorized(createDocumentCookieAccess, cookieOptions)) {\n    return { type: SessionPersistence.COOKIE, cookieOptions, cookieApi: CookieApi.DOCUMENT_COOKIE }\n  }\n\n  return undefined\n}\n\n// Promise chain serializes calls when Web Locks are unavailable\nlet pendingChain: Promise<void> | undefined\n\nexport function initCookieStrategy(\n  sessionStoreStrategyType: CookieSessionStoreStrategyType,\n  configuration: Configuration\n): SessionStoreStrategy {\n  const { cookieOptions, cookieApi } = sessionStoreStrategyType\n  const sessionObservable = new Observable<SessionState>()\n  const trackAnonymousUser = !!configuration.trackAnonymousUser\n  const opts = encodeCookieOptions(cookieOptions)\n  const cookieAccess = mockable(createCookieAccess)(cookieApi, cookieOptions)\n  let isFirstCall = true\n\n  cookieAccess.observable.subscribe(() => {\n    cookieAccess\n      .getAll()\n      .then((cookieValues) => {\n        sessionObservable.notify(findMatchingSessionState(cookieValues, opts))\n      })\n      .catch((error) => monitorError(new Error(`Error while reading session cookies on change: ${error}`)))\n  })\n\n  function applyAndWrite(fn: (state: SessionState) => SessionState) {\n    return cookieAccess.getAllAndSet((cookieValues) => {\n      let currentState = findMatchingSessionState(cookieValues, opts)\n\n      if (isFirstCall && isEmptyObject(currentState)) {\n        currentState = findMatchingSessionState(getCookies(LEGACY_SESSION_STORE_KEY), opts)\n      }\n      isFirstCall = false\n\n      const newState = fn(currentState)\n      const sessionString = buildSessionString(newState, cookieOptions)\n      const expireDelay = trackAnonymousUser ? SESSION_COOKIE_EXPIRATION_DELAY : SESSION_TIME_OUT_DELAY\n\n      return { value: sessionString, expireDelay }\n    })\n  }\n\n  return {\n    async setSessionState(\n      fn: (sessionState: SessionState) => SessionState,\n      _operation: SessionStateOperation\n    ): Promise<void> {\n      if (typeof navigator !== 'undefined' && navigator.locks) {\n        await navigator.locks\n          .request(SESSION_STORE_KEY, () => applyAndWrite(fn))\n          .catch((error: unknown) => {\n            if (isContextGoingAwayError(error)) {\n              return\n            }\n            throw error\n          })\n      } else {\n        pendingChain = (pendingChain ?? Promise.resolve()).then(() => applyAndWrite(fn))\n        await pendingChain\n      }\n    },\n    sessionObservable,\n  }\n}\n\n// Thrown when the browsing context tears down mid-lock-request.\n//   - \"AbortError: Promise was rejected because the browsing context is going away\" (Webkit)\n//   - \"Error: Failed to execute 'request' on 'LockManager': The provided callback is no longer runnable.\" (Chromium)\nfunction isContextGoingAwayError(error: unknown): boolean {\n  if (!(error instanceof Error)) {\n    return false\n  }\n  return error.name === 'AbortError' || error.message.includes('no longer runnable')\n}\n\nexport function createCookieAccess(cookieApi: CookieApi, cookieOptions: CookieOptions): CookieAccess {\n  return cookieApi === CookieApi.COOKIE_STORE\n    ? createCookieStoreAccess(SESSION_STORE_KEY, cookieOptions)\n    : createDocumentCookieAccess(SESSION_STORE_KEY, cookieOptions)\n}\n\nfunction findMatchingSessionState(items: string[], opts: string): SessionState {\n  let sessionState: SessionState | undefined\n\n  // reverse the cookies so that if there is no match, the cookie returned is the first one\n  for (const item of items.slice().reverse()) {\n    sessionState = toSessionState(item)\n    if (sessionState.c === opts) {\n      break\n    }\n  }\n\n  // remove the cookie options from the session state as this is not part of the session state\n  delete sessionState?.c\n\n  return sessionState ?? {}\n}\n\nfunction buildSessionString(sessionState: SessionState, cookieOptions: CookieOptions): string {\n  return toSessionString(\n    isEmptyObject(sessionState) ? sessionState : { ...sessionState, c: encodeCookieOptions(cookieOptions) }\n  )\n}\n\nfunction encodeCookieOptions(cookieOptions: CookieOptions): string {\n  const domainCount = cookieOptions.domain ? cookieOptions.domain.split('.').length - 1 : 0\n\n  /* eslint-disable no-bitwise */\n  let byte = 0\n  byte |= SESSION_COOKIE_VERSION << 5 // Store version in upper 3 bits\n  byte |= domainCount << 1 // Store domain count in next 4 bits\n  byte |= cookieOptions.crossSite ? 1 : 0 // Store useCrossSiteScripting in next bit\n  /* eslint-enable no-bitwise */\n\n  return byte.toString(16) // Convert to hex string\n}\n"],"mappings":";;;;;;;;;;AAyBA,MAAM,yBAAyB;AAE/B,eAAsB,qBACpB,eAC+C;CAC/C,MAAM,EAAE,kBAAkB;CAC1B,IAAI,CAAC,eACH;CAGF,IAAI,uBAAuB,KAAM,MAAM,qBAAqB,yBAAyB,aAAa,GAChG,OAAO;EAAE,MAAM,mBAAmB;EAAQ;EAAe,WAAA;CAAkC;CAG7F,IAAI,MAAM,qBAAqB,4BAA4B,aAAa,GACtE,OAAO;EAAE,MAAM,mBAAmB;EAAQ;EAAe,WAAA;CAAqC;AAIlG;AAGA,IAAI;AAEJ,SAAgB,mBACd,0BACA,eACsB;CACtB,MAAM,EAAE,eAAe,cAAc;CACrC,MAAM,oBAAoB,IAAI,WAAyB;CACvD,MAAM,qBAAqB,CAAC,CAAC,cAAc;CAC3C,MAAM,OAAO,oBAAoB,aAAa;CAC9C,MAAM,eAAe,SAAS,kBAAkB,CAAC,CAAC,WAAW,aAAa;CAC1E,IAAI,cAAc;CAElB,aAAa,WAAW,gBAAgB;EACtC,aACG,OAAO,CAAC,CACR,MAAM,iBAAiB;GACtB,kBAAkB,OAAO,yBAAyB,cAAc,IAAI,CAAC;EACvE,CAAC,CAAC,CACD,OAAO,UAAU,6BAAa,IAAI,MAAM,kDAAkD,OAAO,CAAC,CAAC;CACxG,CAAC;CAED,SAAS,cAAc,IAA2C;EAChE,OAAO,aAAa,cAAc,iBAAiB;GACjD,IAAI,eAAe,yBAAyB,cAAc,IAAI;GAE9D,IAAI,eAAe,cAAc,YAAY,GAC3C,eAAe,yBAAyB,WAAW,wBAAwB,GAAG,IAAI;GAEpF,cAAc;GAMd,OAAO;IAAE,OAHa,mBADL,GAAG,YAC4B,GAAG,aAGvB;IAAG,aAFX,qBAAqB,kCAAkC;GAEhC;EAC7C,CAAC;CACH;CAEA,OAAO;EACL,MAAM,gBACJ,IACA,YACe;GACf,IAAI,OAAO,cAAc,eAAe,UAAU,OAChD,MAAM,UAAU,MACb,QAAQ,yBAAyB,cAAc,EAAE,CAAC,CAAC,CACnD,OAAO,UAAmB;IACzB,IAAI,wBAAwB,KAAK,GAC/B;IAEF,MAAM;GACR,CAAC;QACE;IACL,gBAAgB,gBAAgB,QAAQ,QAAQ,EAAA,CAAG,WAAW,cAAc,EAAE,CAAC;IAC/E,MAAM;GACR;EACF;EACA;CACF;AACF;AAKA,SAAS,wBAAwB,OAAyB;CACxD,IAAI,EAAE,iBAAiB,QACrB,OAAO;CAET,OAAO,MAAM,SAAS,gBAAgB,MAAM,QAAQ,SAAS,oBAAoB;AACnF;AAEA,SAAgB,mBAAmB,WAAsB,eAA4C;CACnG,OAAO,cAAA,IACH,wBAAwB,mBAAmB,aAAa,IACxD,2BAA2B,mBAAmB,aAAa;AACjE;AAEA,SAAS,yBAAyB,OAAiB,MAA4B;CAC7E,IAAI;CAGJ,KAAK,MAAM,QAAQ,MAAM,MAAM,CAAC,CAAC,QAAQ,GAAG;EAC1C,eAAe,eAAe,IAAI;EAClC,IAAI,aAAa,MAAM,MACrB;CAEJ;CAGA,OAAO,cAAc;CAErB,OAAO,gBAAgB,CAAC;AAC1B;AAEA,SAAS,mBAAmB,cAA4B,eAAsC;CAC5F,OAAO,gBACL,cAAc,YAAY,IAAI,eAAe;EAAE,GAAG;EAAc,GAAG,oBAAoB,aAAa;CAAE,CACxG;AACF;AAEA,SAAS,oBAAoB,eAAsC;CACjE,MAAM,cAAc,cAAc,SAAS,cAAc,OAAO,MAAM,GAAG,CAAC,CAAC,SAAS,IAAI;CAGxF,IAAI,OAAO;CACX,QAAQ,0BAA0B;CAClC,QAAQ,eAAe;CACvB,QAAQ,cAAc,YAAY,IAAI;CAGtC,OAAO,KAAK,SAAS,EAAE;AACzB"}

package/esm/domain/session/storeStrategies/sessionInLocalStorage.mjs

@@ -0,0 +1,42 @@
+import { generateUUID } from "../../../tools/utils/stringUtils.mjs";
+import { Observable } from "../../../tools/observable.mjs";
+import { addEventListener } from "../../../browser/addEventListener.mjs";
+import { SessionPersistence } from "../sessionConstants.mjs";
+import { isSessionInNotStartedState, toSessionState, toSessionString } from "../sessionState.mjs";
+import { LEGACY_SESSION_STORE_KEY, SESSION_STORE_KEY } from "./sessionStoreStrategy.mjs";
+//#region src/domain/session/storeStrategies/sessionInLocalStorage.ts
+const LOCAL_STORAGE_TEST_KEY = "_oo_test_";
+function selectLocalStorageStrategy() {
+	try {
+		const id = generateUUID();
+		const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`;
+		localStorage.setItem(testKey, id);
+		const retrievedId = localStorage.getItem(testKey);
+		localStorage.removeItem(testKey);
+		return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : void 0;
+	} catch {
+		return;
+	}
+}
+function initLocalStorageStrategy() {
+	const sessionObservable = new Observable((observable) => addEventListener(window, "storage", (event) => {
+		if (event.key === "_oo_s_v2" && event.storageArea === localStorage) observable.notify(toSessionState(event.newValue));
+	}).stop);
+	let isFirstCall = true;
+	return {
+		async setSessionState(fn, _operation) {
+			let currentState = toSessionState(localStorage.getItem(SESSION_STORE_KEY));
+			if (isFirstCall && isSessionInNotStartedState(currentState)) currentState = toSessionState(localStorage.getItem(LEGACY_SESSION_STORE_KEY));
+			isFirstCall = false;
+			const newState = fn(currentState);
+			localStorage.setItem(SESSION_STORE_KEY, toSessionString(newState));
+			await Promise.resolve();
+			sessionObservable.notify(newState);
+		},
+		sessionObservable
+	};
+}
+//#endregion
+export { initLocalStorageStrategy, selectLocalStorageStrategy };
+
+//# sourceMappingURL=sessionInLocalStorage.mjs.map

package/esm/domain/session/storeStrategies/sessionInLocalStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionInLocalStorage.mjs","names":[],"sources":["../../../../src/domain/session/storeStrategies/sessionInLocalStorage.ts"],"sourcesContent":["import { generateUUID } from '../../../tools/utils/stringUtils'\nimport { Observable } from '../../../tools/observable'\nimport { addEventListener } from '../../../browser/addEventListener'\nimport { SessionPersistence } from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\nimport { isSessionInNotStartedState, toSessionString, toSessionState } from '../sessionState'\nimport type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'\nimport { SESSION_STORE_KEY, LEGACY_SESSION_STORE_KEY } from './sessionStoreStrategy'\n\nconst LOCAL_STORAGE_TEST_KEY = '_oo_test_'\n\nexport function selectLocalStorageStrategy(): SessionStoreStrategyType | undefined {\n  try {\n    const id = generateUUID()\n    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`\n    localStorage.setItem(testKey, id)\n    const retrievedId = localStorage.getItem(testKey)\n    localStorage.removeItem(testKey)\n    return id === retrievedId ? { type: SessionPersistence.LOCAL_STORAGE } : undefined\n  } catch {\n    return undefined\n  }\n}\n\nexport function initLocalStorageStrategy(): SessionStoreStrategy {\n  const sessionObservable = new Observable<SessionState>(\n    (observable) =>\n      addEventListener(window, 'storage', (event) => {\n        if (event.key === SESSION_STORE_KEY && event.storageArea === localStorage) {\n          observable.notify(toSessionState(event.newValue))\n        }\n      }).stop\n  )\n\n  let isFirstCall = true\n\n  return {\n    async setSessionState(\n      fn: (sessionState: SessionState) => SessionState,\n      _operation: SessionStateOperation\n    ): Promise<void> {\n      let currentState = toSessionState(localStorage.getItem(SESSION_STORE_KEY))\n\n      if (isFirstCall && isSessionInNotStartedState(currentState)) {\n        currentState = toSessionState(localStorage.getItem(LEGACY_SESSION_STORE_KEY))\n      }\n      isFirstCall = false\n\n      const newState = fn(currentState)\n      localStorage.setItem(SESSION_STORE_KEY, toSessionString(newState))\n      await Promise.resolve()\n      sessionObservable.notify(newState)\n    },\n    sessionObservable,\n  }\n}\n"],"mappings":";;;;;;;AASA,MAAM,yBAAyB;AAE/B,SAAgB,6BAAmE;CACjF,IAAI;EACF,MAAM,KAAK,aAAa;EACxB,MAAM,UAAU,GAAG,yBAAyB;EAC5C,aAAa,QAAQ,SAAS,EAAE;EAChC,MAAM,cAAc,aAAa,QAAQ,OAAO;EAChD,aAAa,WAAW,OAAO;EAC/B,OAAO,OAAO,cAAc,EAAE,MAAM,mBAAmB,cAAc,IAAI,KAAA;CAC3E,QAAQ;EACN;CACF;AACF;AAEA,SAAgB,2BAAiD;CAC/D,MAAM,oBAAoB,IAAI,YAC3B,eACC,iBAAiB,QAAQ,YAAY,UAAU;EAC7C,IAAI,MAAM,QAAA,cAA6B,MAAM,gBAAgB,cAC3D,WAAW,OAAO,eAAe,MAAM,QAAQ,CAAC;CAEpD,CAAC,CAAC,CAAC,IACP;CAEA,IAAI,cAAc;CAElB,OAAO;EACL,MAAM,gBACJ,IACA,YACe;GACf,IAAI,eAAe,eAAe,aAAa,QAAQ,iBAAiB,CAAC;GAEzE,IAAI,eAAe,2BAA2B,YAAY,GACxD,eAAe,eAAe,aAAa,QAAQ,wBAAwB,CAAC;GAE9E,cAAc;GAEd,MAAM,WAAW,GAAG,YAAY;GAChC,aAAa,QAAQ,mBAAmB,gBAAgB,QAAQ,CAAC;GACjE,MAAM,QAAQ,QAAQ;GACtB,kBAAkB,OAAO,QAAQ;EACnC;EACA;CACF;AACF"}

package/esm/domain/session/storeStrategies/sessionInMemory.mjs

@@ -0,0 +1,33 @@
+import { shallowClone } from "../../../tools/utils/objectUtils.mjs";
+import { globalObject } from "../../../tools/globalObject.mjs";
+import { Observable } from "../../../tools/observable.mjs";
+import { SessionPersistence } from "../sessionConstants.mjs";
+//#region src/domain/session/storeStrategies/sessionInMemory.ts
+const MEMORY_SESSION_STORE_KEY = "_DD_SESSION";
+function selectMemorySessionStoreStrategy() {
+	return { type: SessionPersistence.MEMORY };
+}
+function initMemorySessionStoreStrategy() {
+	const globalObjectWithSession = globalObject;
+	if (!globalObjectWithSession["_DD_SESSION"]) globalObjectWithSession[MEMORY_SESSION_STORE_KEY] = {};
+	const memorySession = globalObjectWithSession[MEMORY_SESSION_STORE_KEY];
+	const sessionObservable = new Observable();
+	const previousOnChange = memorySession.onChange;
+	memorySession.onChange = (state) => {
+		previousOnChange?.(state);
+		sessionObservable.notify(state);
+	};
+	return {
+		async setSessionState(fn, _operation) {
+			const newState = shallowClone(fn(memorySession.state ?? {}));
+			memorySession.state = newState;
+			await Promise.resolve();
+			memorySession.onChange?.(newState);
+		},
+		sessionObservable
+	};
+}
+//#endregion
+export { MEMORY_SESSION_STORE_KEY, initMemorySessionStoreStrategy, selectMemorySessionStoreStrategy };
+
+//# sourceMappingURL=sessionInMemory.mjs.map

package/esm/domain/session/storeStrategies/sessionInMemory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionInMemory.mjs","names":[],"sources":["../../../../src/domain/session/storeStrategies/sessionInMemory.ts"],"sourcesContent":["import { globalObject } from '../../../tools/globalObject'\nimport { Observable } from '../../../tools/observable'\nimport { shallowClone } from '../../../tools/utils/objectUtils'\nimport { SessionPersistence } from '../sessionConstants'\nimport type { SessionState } from '../sessionState'\nimport type { SessionStateOperation, SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'\n\nexport const MEMORY_SESSION_STORE_KEY = '_DD_SESSION'\n\nexport interface MemorySession {\n  state?: SessionState\n  onChange?: (state: SessionState) => void\n}\n\nexport interface GlobalObjectWithSession {\n  [MEMORY_SESSION_STORE_KEY]?: MemorySession\n}\n\nexport function selectMemorySessionStoreStrategy(): SessionStoreStrategyType {\n  return { type: SessionPersistence.MEMORY }\n}\n\nexport function initMemorySessionStoreStrategy(): SessionStoreStrategy {\n  const globalObjectWithSession = globalObject as GlobalObjectWithSession\n\n  // Share the observable across SDK instances (RUM + Logs)\n  if (!globalObjectWithSession[MEMORY_SESSION_STORE_KEY]) {\n    globalObjectWithSession[MEMORY_SESSION_STORE_KEY] = {}\n  }\n  const memorySession = globalObjectWithSession[MEMORY_SESSION_STORE_KEY]\n\n  const sessionObservable = new Observable<SessionState>()\n\n  // Wire the local observable to the shared onChange callback so that\n  // multiple SDK instances (RUM + Logs) can observe each other's changes.\n  const previousOnChange = memorySession.onChange\n  memorySession.onChange = (state: SessionState) => {\n    previousOnChange?.(state)\n    sessionObservable.notify(state)\n  }\n\n  return {\n    async setSessionState(\n      fn: (sessionState: SessionState) => SessionState,\n      _operation: SessionStateOperation\n    ): Promise<void> {\n      const currentState = memorySession.state ?? {}\n      const newState = shallowClone(fn(currentState))\n      memorySession.state = newState\n      await Promise.resolve()\n      memorySession.onChange?.(newState)\n    },\n    sessionObservable,\n  }\n}\n"],"mappings":";;;;;AAOA,MAAa,2BAA2B;AAWxC,SAAgB,mCAA6D;CAC3E,OAAO,EAAE,MAAM,mBAAmB,OAAO;AAC3C;AAEA,SAAgB,iCAAuD;CACrE,MAAM,0BAA0B;CAGhC,IAAI,CAAC,wBAAA,gBACH,wBAAwB,4BAA4B,CAAC;CAEvD,MAAM,gBAAgB,wBAAwB;CAE9C,MAAM,oBAAoB,IAAI,WAAyB;CAIvD,MAAM,mBAAmB,cAAc;CACvC,cAAc,YAAY,UAAwB;EAChD,mBAAmB,KAAK;EACxB,kBAAkB,OAAO,KAAK;CAChC;CAEA,OAAO;EACL,MAAM,gBACJ,IACA,YACe;GAEf,MAAM,WAAW,aAAa,GADT,cAAc,SAAS,CAAC,CACA,CAAC;GAC9C,cAAc,QAAQ;GACtB,MAAM,QAAQ,QAAQ;GACtB,cAAc,WAAW,QAAQ;EACnC;EACA;CACF;AACF"}