@tracelog/lib 0.0.1

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

@@ -0,0 +1,353 @@
+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.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');
+            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')) {
+                try {
+                    this.sessionManager.endSessionSafely('manual_stop', { forceSync: true });
+                    this.clearPersistedSession();
+                    this.stopHeartbeat();
+                }
+                catch (error) {
+                    debugLog.error('SessionHandler', `Manual session stop failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    this.forceCleanupSession();
+                }
+            }
+            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;
+        }
+    }
+    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 };
+    }
+    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');
+        }
+    }
+    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' }),
+        });
+    }
+    startInitialSession() {
+        if (this.get('sessionId')) {
+            debugLog.debug('SessionHandler', 'Session already exists, skipping initial session creation');
+            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;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+import { MetadataType } from '../types';
+import { StateManager } from '../managers/state.manager';
+declare global {
+    interface Window {
+        gtag?: (...args: unknown[]) => void;
+        dataLayer?: unknown[];
+    }
+}
+export declare class GoogleAnalyticsIntegration extends StateManager {
+    private isInitialized;
+    constructor();
+    initialize(): Promise<void>;
+    trackEvent(eventName: string, metadata: Record<string, MetadataType>): void;
+    cleanup(): void;
+    private isScriptAlreadyLoaded;
+    private loadScript;
+    private configureGtag;
+}

package/dist/esm/integrations/google-analytics.integration.js

@@ -0,0 +1,155 @@
+import { debugLog } from '../utils/logging';
+import { StateManager } from '../managers/state.manager';
+export class GoogleAnalyticsIntegration extends StateManager {
+    constructor() {
+        super();
+        this.isInitialized = false;
+    }
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        const measurementId = this.get('config').integrations?.googleAnalytics?.measurementId;
+        if (!measurementId?.trim()) {
+            debugLog.clientWarn('GoogleAnalytics', 'Google Analytics integration disabled - measurementId not configured', {
+                hasIntegrations: !!this.get('config').integrations,
+                hasGoogleAnalytics: !!this.get('config').integrations?.googleAnalytics,
+            });
+            return;
+        }
+        const userId = this.get('userId');
+        if (!userId?.trim()) {
+            debugLog.warn('GoogleAnalytics', 'Google Analytics initialization delayed - userId not available', {
+                measurementId: measurementId.substring(0, 8) + '...',
+            });
+            return;
+        }
+        try {
+            if (this.isScriptAlreadyLoaded()) {
+                debugLog.info('GoogleAnalytics', 'Google Analytics script already loaded', { measurementId });
+                this.isInitialized = true;
+                return;
+            }
+            await this.loadScript(measurementId);
+            this.configureGtag(measurementId, userId);
+            this.isInitialized = true;
+            debugLog.info('GoogleAnalytics', 'Google Analytics integration initialized successfully', {
+                measurementId,
+                userId,
+            });
+        }
+        catch (error) {
+            debugLog.error('GoogleAnalytics', 'Google Analytics initialization failed', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                measurementId,
+                userId,
+            });
+        }
+    }
+    trackEvent(eventName, metadata) {
+        if (!eventName?.trim()) {
+            debugLog.clientWarn('GoogleAnalytics', 'Event tracking skipped - invalid event name provided', {
+                eventName,
+                hasMetadata: !!metadata && Object.keys(metadata).length > 0,
+            });
+            return;
+        }
+        if (!this.isInitialized) {
+            return;
+        }
+        if (typeof window.gtag !== 'function') {
+            debugLog.warn('GoogleAnalytics', 'Event tracking failed - gtag function not available', {
+                eventName,
+                hasGtag: typeof window.gtag,
+                hasDataLayer: Array.isArray(window.dataLayer),
+            });
+            return;
+        }
+        try {
+            window.gtag('event', eventName, metadata);
+        }
+        catch (error) {
+            debugLog.error('GoogleAnalytics', 'Event tracking failed', {
+                eventName,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                metadataKeys: Object.keys(metadata || {}),
+            });
+        }
+    }
+    cleanup() {
+        this.isInitialized = false;
+        const script = document.getElementById('tracelog-ga-script');
+        if (script) {
+            script.remove();
+        }
+        debugLog.info('GoogleAnalytics', 'Google Analytics integration cleanup completed');
+    }
+    isScriptAlreadyLoaded() {
+        const tracelogScript = document.getElementById('tracelog-ga-script');
+        if (tracelogScript) {
+            return true;
+        }
+        const existingGAScript = document.querySelector('script[src*="googletagmanager.com/gtag/js"]');
+        if (existingGAScript) {
+            debugLog.clientWarn('GoogleAnalytics', 'Google Analytics script already loaded from external source', {
+                scriptSrc: existingGAScript.getAttribute('src'),
+                hasGtag: typeof window.gtag === 'function',
+            });
+            return true;
+        }
+        return false;
+    }
+    async loadScript(measurementId) {
+        return new Promise((resolve, reject) => {
+            try {
+                const script = document.createElement('script');
+                script.id = 'tracelog-ga-script';
+                script.async = true;
+                script.src = `https://www.googletagmanager.com/gtag/js?id=${measurementId}`;
+                script.onload = () => {
+                    resolve();
+                };
+                script.onerror = () => {
+                    const error = new Error('Failed to load Google Analytics script');
+                    debugLog.error('GoogleAnalytics', 'Google Analytics script load failed', {
+                        measurementId,
+                        error: error.message,
+                        scriptSrc: script.src,
+                    });
+                    reject(error);
+                };
+                document.head.appendChild(script);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error : new Error(String(error));
+                debugLog.error('GoogleAnalytics', 'Error creating Google Analytics script', {
+                    measurementId,
+                    error: errorMsg.message,
+                });
+                reject(errorMsg);
+            }
+        });
+    }
+    configureGtag(measurementId, userId) {
+        try {
+            const gaScriptConfig = document.createElement('script');
+            gaScriptConfig.innerHTML = `
+        window.dataLayer = window.dataLayer || [];
+        function gtag(){dataLayer.push(arguments);}
+        gtag('js', new Date());
+        gtag('config', '${measurementId}', {
+          'user_id': '${userId}'
+        });
+      `;
+            document.head.appendChild(gaScriptConfig);
+        }
+        catch (error) {
+            debugLog.error('GoogleAnalytics', 'Failed to configure Google Analytics', {
+                measurementId,
+                userId,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            throw error;
+        }
+    }
+}

package/dist/esm/listeners/activity-listener-manager.d.ts

@@ -0,0 +1,8 @@
+import { EventListenerManager } from './listeners.types';
+export declare class ActivityListenerManager implements EventListenerManager {
+    private readonly onActivity;
+    private readonly options;
+    constructor(onActivity: () => void);
+    setup(): void;
+    cleanup(): void;
+}

package/dist/esm/listeners/activity-listener-manager.js

@@ -0,0 +1,28 @@
+import { debugLog } from '../utils/logging';
+export class ActivityListenerManager {
+    constructor(onActivity) {
+        this.options = { passive: true };
+        this.onActivity = onActivity;
+    }
+    setup() {
+        try {
+            window.addEventListener('scroll', this.onActivity, this.options);
+            window.addEventListener('resize', this.onActivity, this.options);
+            window.addEventListener('focus', this.onActivity, this.options);
+        }
+        catch (error) {
+            debugLog.error('ActivityListenerManager', 'Failed to setup activity listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            window.removeEventListener('scroll', this.onActivity);
+            window.removeEventListener('resize', this.onActivity);
+            window.removeEventListener('focus', this.onActivity);
+        }
+        catch (error) {
+            debugLog.warn('ActivityListenerManager', 'Error during activity listeners cleanup', { error });
+        }
+    }
+}

package/dist/esm/listeners/index.d.ts

@@ -0,0 +1,6 @@
+export { ActivityListenerManager } from './activity-listener-manager';
+export { TouchListenerManager } from './touch-listener-manager';
+export { MouseListenerManager, KeyboardListenerManager } from './input-listener-managers';
+export { VisibilityListenerManager } from './visibility-listener-manager';
+export { UnloadListenerManager } from './unload-listener-manager';
+export type { EventListenerManager } from './listeners.types';

package/dist/esm/listeners/index.js

@@ -0,0 +1,5 @@
+export { ActivityListenerManager } from './activity-listener-manager';
+export { TouchListenerManager } from './touch-listener-manager';
+export { MouseListenerManager, KeyboardListenerManager } from './input-listener-managers';
+export { VisibilityListenerManager } from './visibility-listener-manager';
+export { UnloadListenerManager } from './unload-listener-manager';

package/dist/esm/listeners/input-listener-managers.d.ts

@@ -0,0 +1,15 @@
+import { EventListenerManager } from './listeners.types';
+export declare class MouseListenerManager implements EventListenerManager {
+    private readonly onActivity;
+    private readonly options;
+    constructor(onActivity: () => void);
+    setup(): void;
+    cleanup(): void;
+}
+export declare class KeyboardListenerManager implements EventListenerManager {
+    private readonly onActivity;
+    private readonly options;
+    constructor(onActivity: () => void);
+    setup(): void;
+    cleanup(): void;
+}

package/dist/esm/listeners/input-listener-managers.js

@@ -0,0 +1,53 @@
+import { debugLog } from '../utils/logging';
+export class MouseListenerManager {
+    constructor(onActivity) {
+        this.options = { passive: true };
+        this.onActivity = onActivity;
+    }
+    setup() {
+        try {
+            window.addEventListener('mousemove', this.onActivity, this.options);
+            window.addEventListener('mousedown', this.onActivity, this.options);
+            window.addEventListener('wheel', this.onActivity, this.options);
+        }
+        catch (error) {
+            debugLog.error('MouseListenerManager', 'Failed to setup mouse listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            window.removeEventListener('mousemove', this.onActivity);
+            window.removeEventListener('mousedown', this.onActivity);
+            window.removeEventListener('wheel', this.onActivity);
+        }
+        catch (error) {
+            debugLog.warn('MouseListenerManager', 'Error during mouse listeners cleanup', { error });
+        }
+    }
+}
+export class KeyboardListenerManager {
+    constructor(onActivity) {
+        this.options = { passive: true };
+        this.onActivity = onActivity;
+    }
+    setup() {
+        try {
+            window.addEventListener('keydown', this.onActivity, this.options);
+            window.addEventListener('keypress', this.onActivity, this.options);
+        }
+        catch (error) {
+            debugLog.error('KeyboardListenerManager', 'Failed to setup keyboard listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            window.removeEventListener('keydown', this.onActivity);
+            window.removeEventListener('keypress', this.onActivity);
+        }
+        catch (error) {
+            debugLog.warn('KeyboardListenerManager', 'Error during keyboard listeners cleanup', { error });
+        }
+    }
+}

package/dist/esm/listeners/listeners.types.d.ts

@@ -0,0 +1,4 @@
+export interface EventListenerManager {
+    setup(): void;
+    cleanup(): void;
+}

package/dist/esm/listeners/listeners.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/listeners/touch-listener-manager.d.ts

@@ -0,0 +1,10 @@
+import { EventListenerManager } from './listeners.types';
+export declare class TouchListenerManager implements EventListenerManager {
+    private readonly onActivity;
+    private readonly options;
+    private readonly motionThreshold;
+    constructor(onActivity: () => void, motionThreshold: number);
+    setup(): void;
+    cleanup(): void;
+    private readonly handleDeviceMotion;
+}