@tracelog/lib 0.0.8 → 0.2.0

package/dist/esm/handlers/scroll.handler.js

@@ -1,4 +1,4 @@
-import { SCROLL_DEBOUNCE_TIME_MS, SIGNIFICANT_SCROLL_DELTA } from '../constants';
+import { MAX_SCROLL_EVENTS_PER_SESSION, MIN_SCROLL_DEPTH_CHANGE, SCROLL_DEBOUNCE_TIME_MS, SCROLL_MIN_EVENT_INTERVAL_MS, SIGNIFICANT_SCROLL_DELTA, } from '../constants';
 import { EventType, ScrollDirection } from '../types';
 import { StateManager } from '../managers/state.manager';
 import { debugLog } from '../utils/logging';
@@ -6,12 +6,18 @@ export class ScrollHandler extends StateManager {
     constructor(eventManager) {
         super();
         this.containers = [];
+        this.limitWarningLogged = false;
+        this.minDepthChange = MIN_SCROLL_DEPTH_CHANGE;
+        this.minIntervalMs = SCROLL_MIN_EVENT_INTERVAL_MS;
+        this.maxEventsPerSession = MAX_SCROLL_EVENTS_PER_SESSION;
         this.eventManager = eventManager;
     }
     startTracking() {
+        this.limitWarningLogged = false;
+        this.applyConfigOverrides();
+        this.set('scrollEventCount', 0);
         const raw = this.get('config').scrollContainerSelectors;
         const selectors = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];
-        debugLog.debug('ScrollHandler', 'Starting scroll tracking', { selectorsCount: selectors.length });
         const elements = selectors
             .map((sel) => this.safeQuerySelector(sel))
             .filter((element) => element instanceof HTMLElement);
@@ -23,11 +29,8 @@ export class ScrollHandler extends StateManager {
         }
     }
     stopTracking() {
-        debugLog.debug('ScrollHandler', 'Stopping scroll tracking', { containersCount: this.containers.length });
         for (const container of this.containers) {
-            if (container.debounceTimer) {
-                clearTimeout(container.debounceTimer);
-            }
+            this.clearContainerTimer(container);
             if (container.element instanceof Window) {
                 window.removeEventListener('scroll', container.listener);
             }
@@ -36,38 +39,38 @@ export class ScrollHandler extends StateManager {
             }
         }
         this.containers.length = 0;
+        this.set('scrollEventCount', 0);
+        this.limitWarningLogged = false;
     }
     setupScrollContainer(element) {
         // Skip setup for non-scrollable elements
         if (element !== window && !this.isElementScrollable(element)) {
             return;
         }
-        const container = {
-            element,
-            lastScrollPos: this.getScrollTop(element),
-            debounceTimer: null,
-            listener: () => { },
-        };
         const handleScroll = () => {
             if (this.get('suppressNextScroll')) {
-                this.set('suppressNextScroll', false);
                 return;
             }
-            if (container.debounceTimer) {
-                clearTimeout(container.debounceTimer);
-            }
+            this.clearContainerTimer(container);
             container.debounceTimer = window.setTimeout(() => {
                 const scrollData = this.calculateScrollData(container);
                 if (scrollData) {
-                    this.eventManager.track({
-                        type: EventType.SCROLL,
-                        scroll_data: scrollData,
-                    });
+                    const now = Date.now();
+                    this.processScrollEvent(container, scrollData, now);
                 }
                 container.debounceTimer = null;
             }, SCROLL_DEBOUNCE_TIME_MS);
         };
-        container.listener = handleScroll;
+        const initialScrollTop = this.getScrollTop(element);
+        const container = {
+            element,
+            lastScrollPos: initialScrollTop,
+            lastDepth: this.calculateScrollDepth(initialScrollTop, this.getScrollHeight(element), this.getViewportHeight(element)),
+            lastDirection: ScrollDirection.DOWN,
+            lastEventTime: 0,
+            debounceTimer: null,
+            listener: handleScroll,
+        };
         this.containers.push(container);
         if (element instanceof Window) {
             window.addEventListener('scroll', handleScroll, { passive: true });
@@ -76,24 +79,95 @@ export class ScrollHandler extends StateManager {
             element.addEventListener('scroll', handleScroll, { passive: true });
         }
     }
+    processScrollEvent(container, scrollData, timestamp) {
+        if (!this.shouldEmitScrollEvent(container, scrollData, timestamp)) {
+            return;
+        }
+        container.lastEventTime = timestamp;
+        container.lastDepth = scrollData.depth;
+        container.lastDirection = scrollData.direction;
+        const currentCount = this.get('scrollEventCount') ?? 0;
+        this.set('scrollEventCount', currentCount + 1);
+        this.eventManager.track({
+            type: EventType.SCROLL,
+            scroll_data: scrollData,
+        });
+    }
+    shouldEmitScrollEvent(container, scrollData, timestamp) {
+        if (this.hasReachedSessionLimit()) {
+            this.logLimitOnce();
+            return false;
+        }
+        if (!this.hasElapsedMinimumInterval(container, timestamp)) {
+            return false;
+        }
+        if (!this.hasSignificantDepthChange(container, scrollData.depth)) {
+            return false;
+        }
+        return true;
+    }
+    hasReachedSessionLimit() {
+        const currentCount = this.get('scrollEventCount') ?? 0;
+        return currentCount >= this.maxEventsPerSession;
+    }
+    hasElapsedMinimumInterval(container, timestamp) {
+        if (container.lastEventTime === 0) {
+            return true;
+        }
+        return timestamp - container.lastEventTime >= this.minIntervalMs;
+    }
+    hasSignificantDepthChange(container, newDepth) {
+        return Math.abs(newDepth - container.lastDepth) >= this.minDepthChange;
+    }
+    logLimitOnce() {
+        if (this.limitWarningLogged) {
+            return;
+        }
+        this.limitWarningLogged = true;
+        debugLog.warn('ScrollHandler', 'Max scroll events per session reached', {
+            limit: this.maxEventsPerSession,
+        });
+    }
+    applyConfigOverrides() {
+        this.minDepthChange = MIN_SCROLL_DEPTH_CHANGE;
+        this.minIntervalMs = SCROLL_MIN_EVENT_INTERVAL_MS;
+        this.maxEventsPerSession = MAX_SCROLL_EVENTS_PER_SESSION;
+    }
+    isWindowScrollable() {
+        return document.documentElement.scrollHeight > window.innerHeight;
+    }
+    clearContainerTimer(container) {
+        if (container.debounceTimer !== null) {
+            clearTimeout(container.debounceTimer);
+            container.debounceTimer = null;
+        }
+    }
+    getScrollDirection(current, previous) {
+        return current > previous ? ScrollDirection.DOWN : ScrollDirection.UP;
+    }
+    calculateScrollDepth(scrollTop, scrollHeight, viewportHeight) {
+        if (scrollHeight <= viewportHeight) {
+            return 0;
+        }
+        const maxScrollTop = scrollHeight - viewportHeight;
+        return Math.min(100, Math.max(0, Math.floor((scrollTop / maxScrollTop) * 100)));
+    }
     calculateScrollData(container) {
         const { element, lastScrollPos } = container;
         const scrollTop = this.getScrollTop(element);
-        const viewportHeight = this.getViewportHeight(element);
-        const scrollHeight = this.getScrollHeight(element);
-        // Check if the page is actually scrollable at runtime
-        if (element === window && scrollHeight <= viewportHeight) {
-            return null;
-        }
-        const direction = scrollTop > lastScrollPos ? ScrollDirection.DOWN : ScrollDirection.UP;
-        const depth = scrollHeight > viewportHeight
-            ? Math.min(100, Math.max(0, Math.floor((scrollTop / (scrollHeight - viewportHeight)) * 100)))
-            : 0;
-        // Only update if scroll position changed significantly
+        // Early return: check significant movement first (cheapest check)
         const positionDelta = Math.abs(scrollTop - lastScrollPos);
         if (positionDelta < SIGNIFICANT_SCROLL_DELTA) {
             return null;
         }
+        // Early return: check if window is scrollable
+        if (element === window && !this.isWindowScrollable()) {
+            return null;
+        }
+        const viewportHeight = this.getViewportHeight(element);
+        const scrollHeight = this.getScrollHeight(element);
+        const direction = this.getScrollDirection(scrollTop, lastScrollPos);
+        const depth = this.calculateScrollDepth(scrollTop, scrollHeight, viewportHeight);
         container.lastScrollPos = scrollTop;
         return { depth, direction };
     }

package/dist/esm/handlers/session.handler.d.ts

@@ -4,26 +4,12 @@ import { StorageManager } from '../managers/storage.manager';
 export declare class SessionHandler extends StateManager {
     private readonly eventManager;
     private readonly storageManager;
-    private readonly sessionStorageKey;
     private sessionManager;
-    private recoveryManager;
-    private _crossTabSessionManager;
-    private heartbeatInterval;
-    private _isInitializingCrossTab;
-    private get crossTabSessionManager();
-    private shouldUseCrossTabs;
+    private destroyed;
     constructor(storageManager: StorageManager, eventManager: EventManager);
-    startTracking(): void;
-    stopTracking(): void;
-    private initializeSessionRecoveryManager;
-    private initializeCrossTabSessionManager;
-    private createOrJoinSession;
-    private forceCleanupSession;
-    private trackSession;
-    private startInitialSession;
-    private checkOrphanedSessions;
-    private persistSession;
-    private clearPersistedSession;
-    private startHeartbeat;
-    private stopHeartbeat;
+    startTracking(): Promise<void>;
+    private isActive;
+    private cleanupSessionManager;
+    stopTracking(): Promise<void>;
+    destroy(): void;
 }

package/dist/esm/handlers/session.handler.js

@@ -1,353 +1,65 @@
-import { SESSION_HEARTBEAT_INTERVAL_MS, SESSION_STORAGE_KEY, DEFAULT_SESSION_TIMEOUT_MS, SESSION_SYNC_CONSTANTS, } from '../constants';
-import { EventType } from '../types';
 import { SessionManager } from '../managers/session.manager';
-import { SessionRecoveryManager } from '../managers/session-recovery.manager';
-import { CrossTabSessionManager } from '../managers/cross-tab-session.manager';
 import { StateManager } from '../managers/state.manager';
 import { debugLog } from '../utils/logging';
 export class SessionHandler extends StateManager {
-    get crossTabSessionManager() {
-        if (!this._crossTabSessionManager && !this._isInitializingCrossTab && this.shouldUseCrossTabs()) {
-            this._isInitializingCrossTab = true;
-            try {
-                const projectId = this.get('config')?.id;
-                if (projectId) {
-                    this.initializeCrossTabSessionManager(projectId);
-                }
-            }
-            catch (error) {
-                debugLog.error('SessionHandler', 'Failed to initialize cross-tab session manager', {
-                    error: error instanceof Error ? error.message : 'Unknown error',
-                });
-            }
-            finally {
-                this._isInitializingCrossTab = false;
-            }
-        }
-        return this._crossTabSessionManager;
-    }
-    shouldUseCrossTabs() {
-        // Only initialize if BroadcastChannel is supported (indicates potential for multiple tabs)
-        // and ServiceWorker is available (better cross-tab coordination)
-        return typeof BroadcastChannel !== 'undefined' && typeof navigator !== 'undefined' && 'serviceWorker' in navigator;
-    }
     constructor(storageManager, eventManager) {
         super();
         this.sessionManager = null;
-        this.recoveryManager = null;
-        this._crossTabSessionManager = null;
-        this.heartbeatInterval = null;
-        this._isInitializingCrossTab = false;
+        this.destroyed = false;
         this.eventManager = eventManager;
         this.storageManager = storageManager;
-        this.sessionStorageKey = SESSION_STORAGE_KEY(this.get('config')?.id);
-        const projectId = this.get('config')?.id;
-        if (projectId) {
-            this.initializeSessionRecoveryManager(projectId);
-            // CrossTabSessionManager will be initialized lazily when needed via the getter
-        }
     }
-    startTracking() {
-        if (this.sessionManager) {
-            debugLog.debug('SessionHandler', 'Session tracking already active');
+    async startTracking() {
+        if (this.isActive()) {
             return;
         }
-        debugLog.debug('SessionHandler', 'Starting session tracking');
-        this.checkOrphanedSessions();
-        const onActivity = async () => {
-            if (this.crossTabSessionManager) {
-                this.crossTabSessionManager.updateSessionActivity();
-            }
-            if (this.get('sessionId')) {
-                return;
-            }
-            try {
-                const sessionResult = await this.createOrJoinSession();
-                this.set('sessionId', sessionResult.sessionId);
-                debugLog.info('SessionHandler', '🏁 Session started', {
-                    sessionId: sessionResult.sessionId,
-                    recovered: sessionResult.recovered,
-                    crossTabActive: !!this.crossTabSessionManager,
-                });
-                this.trackSession(EventType.SESSION_START, sessionResult.recovered);
-                this.persistSession(sessionResult.sessionId);
-                this.startHeartbeat();
-            }
-            catch (error) {
-                debugLog.error('SessionHandler', `Session creation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                this.forceCleanupSession();
-            }
-        };
-        const onInactivity = () => {
-            if (!this.get('sessionId')) {
-                return;
-            }
-            if (this.crossTabSessionManager && this.crossTabSessionManager.getEffectiveSessionTimeout() > 0) {
-                if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                    debugLog.debug('SessionHandler', 'Session kept alive by cross-tab activity');
-                }
-                return;
-            }
-            this.sessionManager.endSessionManaged('inactivity')
-                .then((result) => {
-                debugLog.info('SessionHandler', '🛑 Session ended by inactivity', {
-                    sessionId: this.get('sessionId'),
-                    reason: result.reason,
-                    success: result.success,
-                    eventsFlushed: result.eventsFlushed,
-                });
-                if (this.crossTabSessionManager) {
-                    this.crossTabSessionManager.endSession('inactivity');
-                }
-                this.clearPersistedSession();
-                this.stopHeartbeat();
-            })
-                .catch((error) => {
-                debugLog.error('SessionHandler', `Session end failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                this.forceCleanupSession();
-            });
-        };
-        const sessionEndConfig = {
-            enablePageUnloadHandlers: true,
-            debugMode: (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') ?? false,
-            syncTimeoutMs: SESSION_SYNC_CONSTANTS.SYNC_TIMEOUT_MS,
-            maxRetries: SESSION_SYNC_CONSTANTS.MAX_RETRY_ATTEMPTS,
-        };
-        this.sessionManager = new SessionManager(onActivity, onInactivity, this.eventManager, this.storageManager, sessionEndConfig);
-        debugLog.debug('SessionHandler', 'Session manager initialized');
-        this.startInitialSession();
-    }
-    stopTracking() {
-        debugLog.info('SessionHandler', 'Stopping session tracking');
-        if (this.sessionManager) {
-            if (this.get('sessionId')) {
+        if (this.destroyed) {
+            debugLog.warn('SessionHandler', 'Cannot start tracking on destroyed handler');
+            return;
+        }
+        try {
+            this.sessionManager = new SessionManager(this.storageManager, this.eventManager);
+            await this.sessionManager.startTracking();
+        }
+        catch (error) {
+            // Cleanup on failure
+            if (this.sessionManager) {
                 try {
-                    this.sessionManager.endSessionSafely('manual_stop', { forceSync: true });
-                    this.clearPersistedSession();
-                    this.stopHeartbeat();
+                    this.sessionManager.destroy();
                 }
-                catch (error) {
-                    debugLog.error('SessionHandler', `Manual session stop failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                    this.forceCleanupSession();
+                catch {
+                    // Ignore cleanup errors
                 }
+                this.sessionManager = null;
             }
-            this.sessionManager.destroy();
-            this.sessionManager = null;
-        }
-        if (this._crossTabSessionManager) {
-            this._crossTabSessionManager.destroy();
-            this._crossTabSessionManager = null;
-        }
-        // Reset cross-tab initialization flag
-        this._isInitializingCrossTab = false;
-        if (this.recoveryManager) {
-            this.recoveryManager.cleanupOldRecoveryAttempts();
-            this.recoveryManager = null;
+            debugLog.error('SessionHandler', 'Failed to start session tracking', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            throw error;
         }
     }
-    initializeSessionRecoveryManager(projectId) {
-        this.recoveryManager = new SessionRecoveryManager(this.storageManager, projectId, this.eventManager);
-        debugLog.debug('SessionHandler', 'Session recovery manager initialized', { projectId });
-    }
-    initializeCrossTabSessionManager(projectId) {
-        const config = {
-            debugMode: (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') ?? false,
-        };
-        const onSessionStart = (sessionId) => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', `Cross-tab session started: ${sessionId}`);
-            }
-            this.set('sessionId', sessionId);
-            this.trackSession(EventType.SESSION_START, false);
-            this.persistSession(sessionId);
-            this.startHeartbeat();
-        };
-        const onSessionEnd = (reason) => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', `Cross-tab session ended: ${reason}`);
-            }
-            this.clearPersistedSession();
-            this.trackSession(EventType.SESSION_END, false, reason);
-        };
-        const onTabActivity = () => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.debug('SessionHandler', 'Cross-tab activity detected');
-            }
-        };
-        const onCrossTabConflict = () => {
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.warn('SessionHandler', 'Cross-tab conflict detected');
-            }
-            // Track cross-tab conflict in session health
-            if (this.sessionManager) {
-                this.sessionManager.trackSessionHealth('conflict');
-            }
-        };
-        const callbacks = {
-            onSessionStart,
-            onSessionEnd,
-            onTabActivity,
-            onCrossTabConflict,
-        };
-        this._crossTabSessionManager = new CrossTabSessionManager(this.storageManager, projectId, config, callbacks);
-        debugLog.debug('SessionHandler', 'Cross-tab session manager initialized', { projectId });
-    }
-    async createOrJoinSession() {
-        if (this.crossTabSessionManager) {
-            const existingSessionId = this.crossTabSessionManager.getSessionId();
-            if (existingSessionId) {
-                return { sessionId: existingSessionId, recovered: false };
-            }
-            // If cross-tab manager exists but no session, create one through regular session manager
-            // The cross-tab manager will coordinate with other tabs automatically
-            const sessionResult = this.sessionManager.startSession();
-            return { sessionId: sessionResult.sessionId, recovered: sessionResult.recovered ?? false };
-        }
-        // Fallback: create regular session when no cross-tab manager
-        const sessionResult = this.sessionManager.startSession();
-        return { sessionId: sessionResult.sessionId, recovered: sessionResult.recovered ?? false };
+    isActive() {
+        return this.sessionManager !== null && !this.destroyed;
     }
-    forceCleanupSession() {
-        // Clear session state
-        this.set('sessionId', null);
-        // Clear persisted session data
-        this.clearPersistedSession();
-        // Stop heartbeat timer
-        this.stopHeartbeat();
-        // Clean up cross-tab session if exists
-        if (this.crossTabSessionManager) {
-            try {
-                this.crossTabSessionManager.endSession('orphaned_cleanup');
-            }
-            catch (error) {
-                // Silent cleanup - we're already in error recovery
-                if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                    debugLog.warn('SessionHandler', `Cross-tab cleanup failed during force cleanup: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                }
-            }
-        }
-        // Track session end for analytics
-        try {
-            this.trackSession(EventType.SESSION_END, false, 'orphaned_cleanup');
-        }
-        catch (error) {
-            // Silent tracking failure - we're already in error recovery
-            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                debugLog.warn('SessionHandler', `Session tracking failed during force cleanup: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            }
-        }
-        if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-            debugLog.debug('SessionHandler', 'Forced session cleanup completed');
+    async cleanupSessionManager() {
+        if (this.sessionManager) {
+            await this.sessionManager.stopTracking();
+            this.sessionManager.destroy();
+            this.sessionManager = null;
         }
     }
-    trackSession(eventType, sessionStartRecovered = false, sessionEndReason) {
-        this.eventManager.track({
-            type: eventType,
-            ...(eventType === EventType.SESSION_START &&
-                sessionStartRecovered && { session_start_recovered: sessionStartRecovered }),
-            ...(eventType === EventType.SESSION_END && { session_end_reason: sessionEndReason ?? 'orphaned_cleanup' }),
-        });
+    async stopTracking() {
+        await this.cleanupSessionManager();
     }
-    startInitialSession() {
-        if (this.get('sessionId')) {
-            debugLog.debug('SessionHandler', 'Session already exists, skipping initial session creation');
+    destroy() {
+        if (this.destroyed) {
             return;
         }
-        debugLog.debug('SessionHandler', 'Starting initial session');
-        // Check if there's already a cross-tab session active
-        if (this.crossTabSessionManager) {
-            const existingSessionId = this.crossTabSessionManager.getSessionId();
-            if (existingSessionId) {
-                // Join existing cross-tab session
-                this.set('sessionId', existingSessionId);
-                this.persistSession(existingSessionId);
-                this.startHeartbeat();
-                return;
-            }
-            // No existing cross-tab session, so trigger activity to potentially create one
-            // The cross-tab session manager will handle session creation when activity occurs
-            return;
-        }
-        // Fallback: no cross-tab session manager, start regular session
-        debugLog.debug('SessionHandler', 'Starting regular session (no cross-tab)');
-        const sessionResult = this.sessionManager.startSession();
-        this.set('sessionId', sessionResult.sessionId);
-        this.trackSession(EventType.SESSION_START, sessionResult.recovered);
-        this.persistSession(sessionResult.sessionId);
-        this.startHeartbeat();
-    }
-    checkOrphanedSessions() {
-        const storedSessionData = this.storageManager.getItem(this.sessionStorageKey);
-        if (storedSessionData) {
-            try {
-                const session = JSON.parse(storedSessionData);
-                const now = Date.now();
-                const timeSinceLastHeartbeat = now - session.lastHeartbeat;
-                const sessionTimeout = this.get('config')?.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT_MS;
-                if (timeSinceLastHeartbeat > sessionTimeout) {
-                    const canRecover = this.recoveryManager?.hasRecoverableSession();
-                    if (canRecover) {
-                        if (this.recoveryManager) {
-                            const sessionContext = {
-                                sessionId: session.sessionId,
-                                startTime: session.startTime,
-                                lastActivity: session.lastHeartbeat,
-                                tabCount: 1,
-                                recoveryAttempts: 0,
-                                metadata: {
-                                    userAgent: navigator.userAgent,
-                                    pageUrl: this.get('pageUrl'),
-                                },
-                            };
-                            this.recoveryManager.storeSessionContextForRecovery(sessionContext);
-                            if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                                debugLog.debug('SessionHandler', `Orphaned session stored for recovery: ${session.sessionId}`);
-                            }
-                        }
-                    }
-                    this.trackSession(EventType.SESSION_END);
-                    this.clearPersistedSession();
-                    if (this.get('config')?.mode === 'qa' || this.get('config')?.mode === 'debug') {
-                        debugLog.debug('SessionHandler', `Orphaned session ended: ${session.sessionId}, recovery available: ${canRecover}`);
-                    }
-                }
-            }
-            catch {
-                this.clearPersistedSession();
-            }
-        }
-    }
-    persistSession(sessionId) {
-        const sessionData = {
-            sessionId,
-            startTime: Date.now(),
-            lastHeartbeat: Date.now(),
-        };
-        this.storageManager.setItem(this.sessionStorageKey, JSON.stringify(sessionData));
-    }
-    clearPersistedSession() {
-        this.storageManager.removeItem(this.sessionStorageKey);
-    }
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.heartbeatInterval = setInterval(() => {
-            const storedSessionData = this.storageManager.getItem(this.sessionStorageKey);
-            if (storedSessionData) {
-                try {
-                    const session = JSON.parse(storedSessionData);
-                    session.lastHeartbeat = Date.now();
-                    this.storageManager.setItem(this.sessionStorageKey, JSON.stringify(session));
-                }
-                catch {
-                    this.clearPersistedSession();
-                }
-            }
-        }, SESSION_HEARTBEAT_INTERVAL_MS);
-    }
-    stopHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
+        if (this.sessionManager) {
+            this.sessionManager.destroy();
+            this.sessionManager = null;
         }
+        this.destroyed = true;
+        this.set('hasStartSession', false);
     }
 }

package/dist/esm/integrations/google-analytics.integration.d.ts

@@ -8,7 +8,6 @@ declare global {
 }
 export declare class GoogleAnalyticsIntegration extends StateManager {
     private isInitialized;
-    constructor();
     initialize(): Promise<void>;
     trackEvent(eventName: string, metadata: Record<string, MetadataType>): void;
     cleanup(): void;