@tracelog/lib 0.0.8 → 0.2.0

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

@@ -1,8 +1,8 @@
-import { debugLog } from '../utils/logging';
+import { debugLog } from '../utils';
 import { StateManager } from '../managers/state.manager';
 export class GoogleAnalyticsIntegration extends StateManager {
     constructor() {
-        super();
+        super(...arguments);
         this.isInitialized = false;
     }
     async initialize() {
@@ -10,69 +10,35 @@ export class GoogleAnalyticsIntegration extends StateManager {
             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) + '...',
-            });
+        if (!measurementId?.trim() || !userId?.trim()) {
             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', {
+            debugLog.error('GoogleAnalyticsIntegration', '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),
-            });
+        if (!eventName?.trim() || !this.isInitialized || typeof window.gtag !== 'function') {
             return;
         }
         try {
             window.gtag('event', eventName, metadata);
         }
         catch (error) {
-            debugLog.error('GoogleAnalytics', 'Event tracking failed', {
-                eventName,
+            debugLog.error('GoogleAnalyticsIntegration', 'Event tracking failed', {
                 error: error instanceof Error ? error.message : 'Unknown error',
-                metadataKeys: Object.keys(metadata || {}),
             });
         }
     }
@@ -82,74 +48,37 @@ export class GoogleAnalyticsIntegration extends StateManager {
         if (script) {
             script.remove();
         }
-        debugLog.info('GoogleAnalytics', 'Google Analytics integration cleanup completed');
     }
     isScriptAlreadyLoaded() {
-        const tracelogScript = document.getElementById('tracelog-ga-script');
-        if (tracelogScript) {
+        // Check if we already loaded the script
+        if (document.getElementById('tracelog-ga-script')) {
             return true;
         }
+        // Check if GA is already loaded by another source
         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;
+        return !!existingGAScript;
     }
     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);
-            }
+            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 = () => reject(new Error('Failed to load Google Analytics script'));
+            document.head.appendChild(script);
         });
     }
     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;
-        }
+        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);
     }
 }

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

@@ -1,15 +1,24 @@
 import { EventListenerManager } from './listeners.types';
-export declare class MouseListenerManager implements EventListenerManager {
-    private readonly onActivity;
-    private readonly options;
+/**
+ * Base class for input listener managers to reduce code duplication
+ */
+declare abstract class BaseInputListenerManager implements EventListenerManager {
+    protected readonly onActivity: () => void;
+    protected readonly options: {
+        passive: boolean;
+    };
+    protected abstract readonly events: string[];
+    protected abstract readonly logPrefix: string;
     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;
+export declare class MouseListenerManager extends BaseInputListenerManager {
+    protected readonly events: string[];
+    protected readonly logPrefix = "MouseListenerManager";
+}
+export declare class KeyboardListenerManager extends BaseInputListenerManager {
+    protected readonly events: string[];
+    protected readonly logPrefix = "KeyboardListenerManager";
 }
+export {};

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

@@ -1,53 +1,44 @@
 import { debugLog } from '../utils/logging';
-export class MouseListenerManager {
+/**
+ * Base class for input listener managers to reduce code duplication
+ */
+class BaseInputListenerManager {
     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);
+            this.events.forEach((event) => {
+                window.addEventListener(event, this.onActivity, this.options);
+            });
         }
         catch (error) {
-            debugLog.error('MouseListenerManager', 'Failed to setup mouse listeners', { error });
-            throw error;
+            debugLog.error(this.logPrefix, `Failed to setup ${this.logPrefix.toLowerCase()} listeners`, { error });
         }
     }
     cleanup() {
         try {
-            window.removeEventListener('mousemove', this.onActivity);
-            window.removeEventListener('mousedown', this.onActivity);
-            window.removeEventListener('wheel', this.onActivity);
+            this.events.forEach((event) => {
+                window.removeEventListener(event, this.onActivity);
+            });
         }
         catch (error) {
-            debugLog.warn('MouseListenerManager', 'Error during mouse listeners cleanup', { error });
+            debugLog.warn(this.logPrefix, `Error during ${this.logPrefix.toLowerCase()} listeners cleanup`, { error });
         }
     }
 }
-export class KeyboardListenerManager {
-    constructor(onActivity) {
-        this.options = { passive: true };
-        this.onActivity = onActivity;
+export class MouseListenerManager extends BaseInputListenerManager {
+    constructor() {
+        super(...arguments);
+        this.events = ['mousemove', 'mousedown', 'wheel'];
+        this.logPrefix = 'MouseListenerManager';
     }
-    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 });
-        }
+}
+export class KeyboardListenerManager extends BaseInputListenerManager {
+    constructor() {
+        super(...arguments);
+        this.events = ['keydown'];
+        this.logPrefix = 'KeyboardListenerManager';
     }
 }

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

@@ -2,9 +2,7 @@ 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);
+    constructor(onActivity: () => void);
     setup(): void;
     cleanup(): void;
-    private readonly handleDeviceMotion;
 }

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

@@ -1,23 +1,8 @@
 import { debugLog } from '../utils/logging';
 export class TouchListenerManager {
-    constructor(onActivity, motionThreshold) {
+    constructor(onActivity) {
         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) {
-                debugLog.warn('TouchListenerManager', 'Error handling device motion event', { error });
-            }
-        };
         this.onActivity = onActivity;
-        this.motionThreshold = motionThreshold;
     }
     setup() {
         try {
@@ -25,10 +10,6 @@ export class TouchListenerManager {
             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) {
             debugLog.error('TouchListenerManager', 'Failed to setup touch listeners', { error });
@@ -41,9 +22,6 @@ export class TouchListenerManager {
             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) {
             debugLog.warn('TouchListenerManager', 'Error during touch listeners cleanup', { error });

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

@@ -2,11 +2,8 @@ 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);
+    constructor(onActivity: () => void, onVisibilityChange: () => void);
     setup(): void;
     cleanup(): void;
-    private setupMobileEvents;
-    private cleanupMobileEvents;
 }

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

@@ -1,31 +1,27 @@
 import { debugLog } from '../utils/logging';
 export class VisibilityListenerManager {
-    constructor(onActivity, onVisibilityChange, isMobile) {
+    constructor(onActivity, onVisibilityChange) {
         this.options = { passive: true };
         this.onActivity = onActivity;
         this.onVisibilityChange = onVisibilityChange;
-        this.isMobile = isMobile;
     }
     setup() {
         try {
-            const hasVisibilityAPI = 'visibilityState' in document;
-            if (hasVisibilityAPI) {
+            // Core visibility API support
+            if ('visibilityState' in document) {
                 document.addEventListener('visibilitychange', this.onVisibilityChange, this.options);
             }
+            // Window focus/blur events
             window.addEventListener('blur', this.onVisibilityChange, this.options);
             window.addEventListener('focus', this.onActivity, this.options);
-            const hasNetworkAPI = 'onLine' in navigator;
-            if (hasNetworkAPI) {
+            // Basic network status detection
+            if ('onLine' in navigator) {
                 window.addEventListener('online', this.onActivity, this.options);
                 window.addEventListener('offline', this.onVisibilityChange, this.options);
             }
-            if (this.isMobile) {
-                this.setupMobileEvents();
-            }
         }
         catch (error) {
             debugLog.error('VisibilityListenerManager', 'Failed to setup visibility listeners', { error });
-            throw error;
         }
     }
     cleanup() {
@@ -39,41 +35,9 @@ export class VisibilityListenerManager {
                 window.removeEventListener('online', this.onActivity);
                 window.removeEventListener('offline', this.onVisibilityChange);
             }
-            if (this.isMobile) {
-                this.cleanupMobileEvents();
-            }
         }
         catch (error) {
             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) {
-            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) {
-            debugLog.warn('VisibilityListenerManager', 'Error during mobile listeners cleanup', { error });
-        }
-    }
 }

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

@@ -1,3 +1,13 @@
-export declare class ApiManager {
-    getUrl(id: string, allowHttp?: boolean): string;
-}
+/**
+ * Generates API URL for TraceLog service based on project ID
+ *
+ * Handles two special cases:
+ * - 'localhost:PORT' - for local development (generates http://localhost:PORT)
+ * - Regular project IDs - generates subdomain URLs via getApiUrl utility
+ *
+ * @param id Project ID or localhost address
+ * @param allowHttp Whether to allow HTTP protocol (default: false)
+ * @returns Generated API URL
+ * @throws Error if URL generation or validation fails
+ */
+export declare function getApiUrlForProject(id: string, allowHttp?: boolean): string;

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

@@ -1,10 +1,41 @@
 import { getApiUrl, isValidUrl } from '../utils';
-export class ApiManager {
-    getUrl(id, allowHttp = false) {
+import { SpecialProjectId } from '../types';
+import { debugLog } from '../utils/logging';
+/**
+ * Generates API URL for TraceLog service based on project ID
+ *
+ * Handles two special cases:
+ * - 'localhost:PORT' - for local development (generates http://localhost:PORT)
+ * - Regular project IDs - generates subdomain URLs via getApiUrl utility
+ *
+ * @param id Project ID or localhost address
+ * @param allowHttp Whether to allow HTTP protocol (default: false)
+ * @returns Generated API URL
+ * @throws Error if URL generation or validation fails
+ */
+export function getApiUrlForProject(id, allowHttp = false) {
+    try {
+        // Handle localhost development case
+        if (id.startsWith(SpecialProjectId.Localhost)) {
+            const url = `http://${id}`;
+            if (!isValidUrl(url, true)) {
+                throw new Error(`Invalid localhost URL format: ${id}`);
+            }
+            return url;
+        }
+        // Handle regular project ID case
         const url = getApiUrl(id, allowHttp);
         if (!isValidUrl(url, allowHttp)) {
-            throw new Error('Invalid URL');
+            throw new Error(`Generated API URL failed validation: ${url}`);
         }
         return url;
     }
+    catch (error) {
+        debugLog.error('ApiManager', 'API URL generation failed', {
+            projectId: id,
+            allowHttp,
+            error: error instanceof Error ? error.message : error,
+        });
+        throw error;
+    }
 }

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

@@ -1,7 +1,57 @@
 import { AppConfig, Config } from '../types';
+/**
+ * Configuration manager responsible for loading and merging application configuration.
+ *
+ * Handles three configuration sources:
+ * 1. Default configuration (fallback values)
+ * 2. API configuration (server-side settings)
+ * 3. App configuration (client initialization settings)
+ *
+ * Supports special project IDs for development and testing:
+ * - 'skip': Bypasses all network calls, uses defaults
+ * - 'localhost:PORT': Loads config from local development server
+ */
 export declare class ConfigManager {
+    private static readonly LOCALHOST_PATTERN;
+    private static readonly PRODUCTION_DOMAINS;
+    /**
+     * Gets complete configuration by merging default, API, and app configurations.
+     *
+     * @param apiUrl - Base URL for the configuration API
+     * @param appConfig - Client-side configuration from init()
+     * @returns Promise<Config> - Merged configuration object
+     */
     get(apiUrl: string, appConfig: AppConfig): Promise<Config>;
-    private load;
-    private getUrl;
-    private getDefaultConfig;
+    /**
+     * Loads configuration from API and merges with app config.
+     */
+    private loadFromApi;
+    /**
+     * Builds the configuration URL based on project type and QA mode.
+     */
+    private buildConfigUrl;
+    /**
+     * Builds request headers based on project configuration.
+     */
+    private buildHeaders;
+    /**
+     * Parses and validates JSON response from config API.
+     */
+    private parseJsonResponse;
+    /**
+     * Validates localhost project ID format and port range.
+     */
+    private validateLocalhostProjectId;
+    /**
+     * Checks if QA mode is enabled via URL parameter.
+     */
+    private isQaModeEnabled;
+    /**
+     * Merges API configuration with app configuration and applies mode-specific settings.
+     */
+    private mergeConfigurations;
+    /**
+     * Creates default configuration for skip mode and fallback scenarios.
+     */
+    private createDefaultConfig;
 }