@tracelog/lib 0.0.1

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

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

package/dist/cjs/listeners/listeners.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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;
+}

package/dist/cjs/listeners/touch-listener-manager.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchListenerManager = void 0;
+const logging_1 = require("../utils/logging");
+class TouchListenerManager {
+    constructor(onActivity, motionThreshold) {
+        this.options = { passive: true };
+        this.handleDeviceMotion = (event) => {
+            try {
+                const acceleration = event.acceleration;
+                if (acceleration) {
+                    const totalAcceleration = Math.abs(acceleration.x ?? 0) + Math.abs(acceleration.y ?? 0) + Math.abs(acceleration.z ?? 0);
+                    if (totalAcceleration > this.motionThreshold) {
+                        this.onActivity();
+                    }
+                }
+            }
+            catch (error) {
+                logging_1.debugLog.warn('TouchListenerManager', 'Error handling device motion event', { error });
+            }
+        };
+        this.onActivity = onActivity;
+        this.motionThreshold = motionThreshold;
+    }
+    setup() {
+        try {
+            window.addEventListener('touchstart', this.onActivity, this.options);
+            window.addEventListener('touchmove', this.onActivity, this.options);
+            window.addEventListener('touchend', this.onActivity, this.options);
+            window.addEventListener('orientationchange', this.onActivity, this.options);
+            const hasDeviceMotion = 'DeviceMotionEvent' in window;
+            if (hasDeviceMotion) {
+                window.addEventListener('devicemotion', this.handleDeviceMotion, this.options);
+            }
+        }
+        catch (error) {
+            logging_1.debugLog.error('TouchListenerManager', 'Failed to setup touch listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            window.removeEventListener('touchstart', this.onActivity);
+            window.removeEventListener('touchmove', this.onActivity);
+            window.removeEventListener('touchend', this.onActivity);
+            window.removeEventListener('orientationchange', this.onActivity);
+            if ('DeviceMotionEvent' in window) {
+                window.removeEventListener('devicemotion', this.handleDeviceMotion);
+            }
+        }
+        catch (error) {
+            logging_1.debugLog.warn('TouchListenerManager', 'Error during touch listeners cleanup', { error });
+        }
+    }
+}
+exports.TouchListenerManager = TouchListenerManager;

package/dist/cjs/listeners/unload-listener-manager.d.ts

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

package/dist/cjs/listeners/unload-listener-manager.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnloadListenerManager = void 0;
+const logging_1 = require("../utils/logging");
+class UnloadListenerManager {
+    constructor(onInactivity) {
+        this.options = { passive: true };
+        this.onInactivity = onInactivity;
+    }
+    setup() {
+        try {
+            window.addEventListener('beforeunload', this.onInactivity, this.options);
+            window.addEventListener('pagehide', this.onInactivity, this.options);
+        }
+        catch (error) {
+            logging_1.debugLog.error('UnloadListenerManager', 'Failed to setup unload listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            window.removeEventListener('beforeunload', this.onInactivity);
+            window.removeEventListener('pagehide', this.onInactivity);
+        }
+        catch (error) {
+            logging_1.debugLog.warn('UnloadListenerManager', 'Error during unload listeners cleanup', { error });
+        }
+    }
+}
+exports.UnloadListenerManager = UnloadListenerManager;

package/dist/cjs/listeners/visibility-listener-manager.d.ts

@@ -0,0 +1,12 @@
+import { EventListenerManager } from './listeners.types';
+export declare class VisibilityListenerManager implements EventListenerManager {
+    private readonly onActivity;
+    private readonly onVisibilityChange;
+    private readonly isMobile;
+    private readonly options;
+    constructor(onActivity: () => void, onVisibilityChange: () => void, isMobile: boolean);
+    setup(): void;
+    cleanup(): void;
+    private setupMobileEvents;
+    private cleanupMobileEvents;
+}

package/dist/cjs/listeners/visibility-listener-manager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisibilityListenerManager = void 0;
+const logging_1 = require("../utils/logging");
+class VisibilityListenerManager {
+    constructor(onActivity, onVisibilityChange, isMobile) {
+        this.options = { passive: true };
+        this.onActivity = onActivity;
+        this.onVisibilityChange = onVisibilityChange;
+        this.isMobile = isMobile;
+    }
+    setup() {
+        try {
+            const hasVisibilityAPI = 'visibilityState' in document;
+            if (hasVisibilityAPI) {
+                document.addEventListener('visibilitychange', this.onVisibilityChange, this.options);
+            }
+            window.addEventListener('blur', this.onVisibilityChange, this.options);
+            window.addEventListener('focus', this.onActivity, this.options);
+            const hasNetworkAPI = 'onLine' in navigator;
+            if (hasNetworkAPI) {
+                window.addEventListener('online', this.onActivity, this.options);
+                window.addEventListener('offline', this.onVisibilityChange, this.options);
+            }
+            if (this.isMobile) {
+                this.setupMobileEvents();
+            }
+        }
+        catch (error) {
+            logging_1.debugLog.error('VisibilityListenerManager', 'Failed to setup visibility listeners', { error });
+            throw error;
+        }
+    }
+    cleanup() {
+        try {
+            if ('visibilityState' in document) {
+                document.removeEventListener('visibilitychange', this.onVisibilityChange);
+            }
+            window.removeEventListener('blur', this.onVisibilityChange);
+            window.removeEventListener('focus', this.onActivity);
+            if ('onLine' in navigator) {
+                window.removeEventListener('online', this.onActivity);
+                window.removeEventListener('offline', this.onVisibilityChange);
+            }
+            if (this.isMobile) {
+                this.cleanupMobileEvents();
+            }
+        }
+        catch (error) {
+            logging_1.debugLog.warn('VisibilityListenerManager', 'Error during visibility listeners cleanup', { error });
+        }
+    }
+    setupMobileEvents() {
+        try {
+            document.addEventListener('pause', this.onVisibilityChange, this.options);
+            document.addEventListener('resume', this.onActivity, this.options);
+            const hasOrientationAPI = 'orientation' in screen;
+            if (hasOrientationAPI) {
+                screen.orientation.addEventListener('change', this.onActivity, this.options);
+            }
+            window.addEventListener('pageshow', this.onActivity, this.options);
+            window.addEventListener('pagehide', this.onActivity, this.options);
+        }
+        catch (error) {
+            logging_1.debugLog.warn('VisibilityListenerManager', 'Failed to setup mobile listeners', { error });
+        }
+    }
+    cleanupMobileEvents() {
+        try {
+            document.removeEventListener('pause', this.onVisibilityChange);
+            document.removeEventListener('resume', this.onActivity);
+            if ('orientation' in screen) {
+                screen.orientation.removeEventListener('change', this.onActivity);
+            }
+            window.removeEventListener('pageshow', this.onActivity);
+            window.removeEventListener('pagehide', this.onActivity);
+        }
+        catch (error) {
+            logging_1.debugLog.warn('VisibilityListenerManager', 'Error during mobile listeners cleanup', { error });
+        }
+    }
+}
+exports.VisibilityListenerManager = VisibilityListenerManager;

package/dist/cjs/managers/api.manager.d.ts

@@ -0,0 +1,3 @@
+export declare class ApiManager {
+    getUrl(id: string, allowHttp?: boolean): string;
+}

package/dist/cjs/managers/api.manager.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiManager = void 0;
+const utils_1 = require("../utils");
+class ApiManager {
+    getUrl(id, allowHttp = false) {
+        const url = (0, utils_1.getApiUrl)(id, allowHttp);
+        if (!(0, utils_1.isValidUrl)(url, allowHttp)) {
+            throw new Error('Invalid URL');
+        }
+        return url;
+    }
+}
+exports.ApiManager = ApiManager;

package/dist/cjs/managers/config.manager.d.ts

@@ -0,0 +1,7 @@
+import { AppConfig, Config } from '../types';
+export declare class ConfigManager {
+    get(apiUrl: string, appConfig: AppConfig): Promise<Config>;
+    private load;
+    private getUrl;
+    private getDefaultConfig;
+}

package/dist/cjs/managers/config.manager.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const logging_1 = require("../utils/logging");
+class ConfigManager {
+    async get(apiUrl, appConfig) {
+        if (appConfig.id === types_1.SpecialProjectId.HttpSkip) {
+            logging_1.debugLog.debug('ConfigManager', 'Using special project id');
+            return this.getDefaultConfig(appConfig);
+        }
+        logging_1.debugLog.debug('ConfigManager', 'Loading config from API', { apiUrl, projectId: appConfig.id });
+        const config = await this.load(apiUrl, appConfig, appConfig.id === types_1.SpecialProjectId.HttpLocal);
+        logging_1.debugLog.info('ConfigManager', 'Config loaded successfully', {
+            projectId: appConfig.id,
+            mode: config.mode,
+            hasExcludedPaths: !!config.excludedUrlPaths?.length,
+            hasGlobalMetadata: !!config.globalMetadata,
+        });
+        return config;
+    }
+    async load(apiUrl, appConfig, useLocalServer) {
+        try {
+            const configUrl = useLocalServer ? `${window.location.origin}/config` : this.getUrl(apiUrl);
+            if (!configUrl) {
+                throw new Error('Config URL is not valid or not allowed');
+            }
+            const response = await fetch(configUrl, {
+                method: 'GET',
+                headers: { 'Content-Type': 'application/json' },
+            });
+            if (!response.ok) {
+                const error = `HTTP ${response.status}: ${response.statusText}`;
+                logging_1.debugLog.error('ConfigManager', 'Config API request failed', {
+                    status: response.status,
+                    statusText: response.statusText,
+                    configUrl,
+                });
+                throw new Error(error);
+            }
+            const rawData = await response.json();
+            if (rawData === undefined || rawData === null || typeof rawData !== 'object' || Array.isArray(rawData)) {
+                logging_1.debugLog.error('ConfigManager', 'Invalid config API response format', {
+                    responseType: typeof rawData,
+                    isArray: Array.isArray(rawData),
+                });
+                throw new Error('Invalid config API response: expected object');
+            }
+            const safeApiConfig = (0, utils_1.sanitizeApiConfig)(rawData);
+            const apiConfig = { ...constants_1.DEFAULT_API_CONFIG, ...safeApiConfig };
+            const mergedConfig = { ...apiConfig, ...appConfig };
+            // Check if qaMode=true is in URL and automatically set mode to 'qa'
+            const urlParameters = new URLSearchParams(window.location.search);
+            const isQaMode = urlParameters.get('qaMode') === 'true';
+            if (isQaMode && !mergedConfig.mode) {
+                mergedConfig.mode = types_1.Mode.QA;
+                logging_1.debugLog.info('ConfigManager', 'QA mode enabled via URL parameter');
+            }
+            const errorSampling = Object.values(types_1.Mode).includes(mergedConfig.mode)
+                ? 1
+                : (mergedConfig.errorSampling ?? 0.1);
+            const finalConfig = { ...mergedConfig, errorSampling };
+            return finalConfig;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logging_1.debugLog.error('ConfigManager', 'Failed to load config', { error: errorMessage, apiUrl });
+            throw new Error(`Failed to load config: ${errorMessage}`);
+        }
+    }
+    getUrl(apiUrl) {
+        const urlParameters = new URLSearchParams(window.location.search);
+        const isQaMode = urlParameters.get('qaMode') === 'true';
+        let configUrl = `${apiUrl}/config`;
+        if (isQaMode) {
+            configUrl += '?qaMode=true';
+        }
+        if (!(0, utils_1.isValidUrl)(configUrl)) {
+            logging_1.debugLog.clientError('ConfigManager', 'Invalid config URL provided', { configUrl });
+            throw new Error('Config URL is not valid or not allowed');
+        }
+        return configUrl;
+    }
+    getDefaultConfig(appConfig) {
+        return (0, constants_1.DEFAULT_CONFIG)({
+            ...appConfig,
+            errorSampling: 1,
+            ...(Object.values(types_1.SpecialProjectId).includes(appConfig.id) && { mode: types_1.Mode.DEBUG }),
+        });
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/cjs/managers/cross-tab-session.manager.d.ts

@@ -0,0 +1,170 @@
+import { CrossTabSessionConfig, SessionEndReason } from '../types/session.types';
+import { StateManager } from './state.manager';
+import { StorageManager } from './storage.manager';
+export declare class CrossTabSessionManager extends StateManager {
+    private readonly callbacks?;
+    private readonly config;
+    private readonly storageManager;
+    private readonly broadcastChannel;
+    private readonly tabId;
+    private readonly tabInfo;
+    private readonly projectId;
+    private leaderTabId;
+    private isTabLeader;
+    private heartbeatInterval;
+    private electionTimeout;
+    private cleanupTimeout;
+    private sessionEnded;
+    private fallbackLeadershipTimeout;
+    private electionDelayTimeout;
+    private tabInfoCleanupTimeout;
+    private closingAnnouncementTimeout;
+    private leaderHealthCheckInterval;
+    private lastHeartbeatSent;
+    constructor(storageManager: StorageManager, projectId: string, config?: Partial<CrossTabSessionConfig>, callbacks?: {
+        onSessionStart?: (sessionId: string) => void;
+        onSessionEnd?: (reason: SessionEndReason) => void;
+        onTabActivity?: () => void;
+        onCrossTabConflict?: () => void;
+    } | undefined);
+    /**
+     * Initialize BroadcastChannel if supported
+     */
+    private initializeBroadcastChannel;
+    /**
+     * Initialize the cross-tab session manager
+     */
+    private initialize;
+    /**
+     * Check if this tab should be the session leader
+     */
+    private tryJoinExistingSession;
+    /**
+     * Request leadership status from other tabs
+     */
+    private requestLeadershipStatus;
+    /**
+     * Start leader election process with debouncing to prevent excessive elections
+     */
+    private startLeaderElection;
+    /**
+     * Become the session leader
+     */
+    private becomeLeader;
+    /**
+     * Announce session start to other tabs
+     */
+    private announceSessionStart;
+    /**
+     * Announce leadership to other tabs
+     */
+    private announceLeadership;
+    /**
+     * Setup fallback mechanism to ensure a leader is always elected
+     */
+    private setupLeadershipFallback;
+    /**
+     * Setup BroadcastChannel event listeners
+     */
+    private setupBroadcastListeners;
+    /**
+     * Handle cross-tab messages
+     */
+    private handleCrossTabMessage;
+    /**
+     * Handle heartbeat message from another tab
+     */
+    private handleHeartbeatMessage;
+    /**
+     * Handle session start message from another tab
+     */
+    private handleSessionStartMessage;
+    /**
+     * Handle session end message from another tab
+     */
+    private handleSessionEndMessage;
+    /**
+     * Handle tab closing message from another tab
+     */
+    private handleTabClosingMessage;
+    /**
+     * Handle election request from another tab
+     */
+    private handleElectionRequest;
+    /**
+     * Handle election response from another tab
+     */
+    private handleElectionResponse;
+    /**
+     * Start heartbeat to keep session active
+     */
+    private startHeartbeat;
+    /**
+     * Send heartbeat to other tabs with rate limiting to prevent flooding
+     */
+    private sendHeartbeat;
+    /**
+     * Update tab info with current timestamp
+     */
+    private updateTabInfo;
+    /**
+     * End session and notify other tabs
+     */
+    endSession(reason: SessionEndReason): void;
+    /**
+     * Announce tab is closing to other tabs
+     */
+    private announceTabClosing;
+    /**
+     * Announce session end to other tabs
+     */
+    private announceSessionEnd;
+    /**
+     * Get current session ID
+     */
+    getSessionId(): string;
+    /**
+     * Get current tab ID
+     */
+    getTabId(): string;
+    /**
+     * Check if this tab is the session leader
+     */
+    isLeader(): boolean;
+    /**
+     * Get current session context from storage
+     */
+    private getStoredSessionContext;
+    /**
+     * Store session context to localStorage
+     */
+    private storeSessionContext;
+    /**
+     * Clear stored session context
+     */
+    private clearStoredSessionContext;
+    /**
+     * Store tab info to localStorage
+     */
+    private storeTabInfo;
+    /**
+     * Clear tab info from localStorage
+     */
+    private clearTabInfo;
+    /**
+     * Check if BroadcastChannel is supported
+     */
+    private isBroadcastChannelSupported;
+    /**
+     * Get session timeout considering cross-tab activity
+     */
+    getEffectiveSessionTimeout(): number;
+    /**
+     * Update session activity from any tab
+     */
+    updateSessionActivity(): void;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}