@tracelog/lib 0.0.8 → 0.2.0

package/dist/cjs/api.d.ts

@@ -1,15 +1,12 @@
-import { MetadataType } from './types/common.types';
-import { AppConfig } from './types/config.types';
+import { MetadataType, AppConfig, EmitterCallback, EmitterMap } from './types';
 import './types/window.types';
-export * as Types from './app.types';
-export * as Constants from './app.constants';
 /**
  * Initializes the tracelog app with the provided configuration.
  * If already initialized, this function returns early without error.
  * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization is currently in progress
+ * @throws {Error} If initialization fails or environment is invalid
  * @example
- * await init({ id: 'my-project-id' });
+ * await tracelog.init({ id: 'my-project-id' });
  */
 export declare const init: (appConfig: AppConfig) => Promise<void>;
 /**
@@ -18,29 +15,46 @@ export declare const init: (appConfig: AppConfig) => Promise<void>;
  * @param metadata - Optional metadata to attach to the event.
  * @example
  * // Send a custom event with metadata
- * event('user_signup', { method: 'email', plan: 'premium' });
+ * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
  * @example
  * // Send a custom event without metadata
- * event('user_login');
+ * tracelog.event('user_login');
  * @remarks
- * This function should be called after the app has been initialized using the `init` function.
+ * This function should be called after the app has been initialized using the `tracelog.init` function.
  */
 export declare const event: (name: string, metadata?: Record<string, MetadataType>) => void;
+/**
+ * Subscribe to events emitted by TraceLog
+ * @param event - Event name to listen to
+ * @param callback - Function to call when event is emitted
+ * @example
+ * // Listen for real-time events
+ * tracelog.on('realtime', (data) => {
+ *   console.log('Event tracked:', data.type, data.data);
+ * });
+ *
+ * // Listen for sent events
+ * tracelog.on('sent', (data) => {
+ *   console.log('Events sent:', data.eventCount);
+ * });
+ */
+export declare const on: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
+/**
+ * Unsubscribe from events emitted by TraceLog
+ * @param event - Event name to stop listening to
+ * @param callback - The same function reference that was used in on()
+ * @example
+ * // Remove a specific listener
+ * tracelog.off('realtime', myCallback);
+ */
+export declare const off: <K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>) => void;
 /**
  * Checks if the app has been initialized.
  * @returns true if the app is initialized, false otherwise
  */
 export declare const isInitialized: () => boolean;
-/**
- * Gets the current initialization status for debugging purposes.
- * @returns Object with detailed initialization state
- */
-export declare const getInitializationStatus: () => {
-    isInitialized: boolean;
-    isInitializing: boolean;
-    hasInstance: boolean;
-};
 /**
  * Destroys the current app instance and cleans up resources.
+ * @throws {Error} If not initialized or already destroying
  */
-export declare const destroy: () => void;
+export declare const destroy: () => Promise<void>;

package/dist/cjs/api.js

@@ -1,121 +1,59 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.destroy = exports.getInitializationStatus = exports.isInitialized = exports.event = exports.init = exports.Constants = exports.Types = void 0;
+exports.destroy = exports.isInitialized = exports.off = exports.on = exports.event = exports.init = void 0;
 const app_1 = require("./app");
-const logging_1 = require("./utils/logging");
-const validations_1 = require("./utils/validations");
-const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const test_bridge_1 = require("./test-bridge");
 require("./types/window.types");
-exports.Types = __importStar(require("./app.types"));
-exports.Constants = __importStar(require("./app.constants"));
 let app = null;
 let isInitializing = false;
+let isDestroying = false;
 /**
  * Initializes the tracelog app with the provided configuration.
  * If already initialized, this function returns early without error.
  * @param appConfig - The configuration object for the app
- * @throws {Error} If initialization is currently in progress
+ * @throws {Error} If initialization fails or environment is invalid
  * @example
- * await init({ id: 'my-project-id' });
+ * await tracelog.init({ id: 'my-project-id' });
  */
 const init = async (appConfig) => {
+    // Browser environment check
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        throw new Error('This library can only be used in a browser environment');
+    }
+    // Already initialized - safe to return
+    if (app) {
+        utils_1.debugLog.debug('API', 'Library already initialized, skipping duplicate initialization');
+        return;
+    }
+    // Prevent concurrent initialization
+    if (isInitializing) {
+        utils_1.debugLog.warn('API', 'Initialization already in progress');
+        throw new Error('Initialization already in progress');
+    }
+    isInitializing = true;
     try {
-        logging_1.debugLog.info('API', 'Library initialization started', { id: appConfig.id });
-        if (typeof window === 'undefined' || typeof document === 'undefined') {
-            logging_1.debugLog.clientError('API', 'Browser environment required - this library can only be used in a browser environment', {
-                hasWindow: typeof window !== 'undefined',
-                hasDocument: typeof document !== 'undefined',
-            });
-            throw new Error('This library can only be used in a browser environment');
-        }
-        if (app) {
-            logging_1.debugLog.debug('API', 'Library already initialized, skipping duplicate initialization', {
-                projectId: appConfig.id,
-            });
-            return;
-        }
-        if (isInitializing) {
-            logging_1.debugLog.debug('API', 'Concurrent initialization detected, waiting for completion', { projectId: appConfig.id });
-            let retries = 0;
-            const maxRetries = constants_1.INITIALIZATION_CONSTANTS.MAX_CONCURRENT_RETRIES;
-            const retryDelay = constants_1.INITIALIZATION_CONSTANTS.CONCURRENT_RETRY_DELAY_MS;
-            while (isInitializing && retries < maxRetries) {
-                await new Promise((resolve) => setTimeout(resolve, retryDelay));
-                retries++;
-            }
-            if (app) {
-                logging_1.debugLog.debug('API', 'Concurrent initialization completed successfully', {
-                    projectId: appConfig.id,
-                    retriesUsed: retries,
-                });
-                return;
-            }
-            if (isInitializing) {
-                logging_1.debugLog.error('API', 'Initialization timeout - concurrent initialization took too long', {
-                    projectId: appConfig.id,
-                    retriesUsed: retries,
-                    maxRetries,
-                });
-                throw new Error('App initialization timeout - concurrent initialization took too long');
-            }
-        }
-        isInitializing = true;
-        logging_1.debugLog.debug('API', 'Validating and normalizing configuration', { projectId: appConfig.id });
-        const validatedConfig = (0, validations_1.validateAndNormalizeConfig)(appConfig);
-        logging_1.debugLog.debug('API', 'Creating App instance', { projectId: validatedConfig.id });
+        utils_1.debugLog.info('API', 'Initializing TraceLog', { projectId: appConfig.id });
+        const validatedConfig = (0, utils_1.validateAndNormalizeConfig)(appConfig);
         const instance = new app_1.App();
-        await instance.init(validatedConfig);
-        app = instance;
-        logging_1.debugLog.info('API', 'Library initialization completed successfully', {
-            projectId: validatedConfig.id,
-        });
-    }
-    catch (error) {
-        // Ensure complete cleanup on initialization failure
-        if (app && !app.initialized) {
-            // Clean up partially initialized app instance
+        try {
+            await instance.init(validatedConfig);
+            app = instance;
+            utils_1.debugLog.info('API', 'TraceLog initialized successfully', { projectId: validatedConfig.id });
+        }
+        catch (error) {
             try {
-                app.destroy();
+                await instance.destroy(true);
             }
             catch (cleanupError) {
-                logging_1.debugLog.warn('API', 'Failed to cleanup partially initialized app', { cleanupError });
+                utils_1.debugLog.warn('API', 'Failed to cleanup partially initialized app', { cleanupError });
             }
+            throw error;
         }
+    }
+    catch (error) {
         app = null;
-        logging_1.debugLog.error('API', 'Initialization failed', { error });
+        utils_1.debugLog.error('API', 'Initialization failed', { error });
         throw error;
     }
     finally {
@@ -129,38 +67,63 @@ exports.init = init;
  * @param metadata - Optional metadata to attach to the event.
  * @example
  * // Send a custom event with metadata
- * event('user_signup', { method: 'email', plan: 'premium' });
+ * tracelog.event('user_signup', { method: 'email', plan: 'premium' });
  * @example
  * // Send a custom event without metadata
- * event('user_login');
+ * tracelog.event('user_login');
  * @remarks
- * This function should be called after the app has been initialized using the `init` function.
+ * This function should be called after the app has been initialized using the `tracelog.init` function.
  */
 const event = (name, metadata) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
+    }
     try {
-        if (!app) {
-            logging_1.debugLog.clientError('API', 'Custom event failed - Library not initialized. Please call TraceLog.init() first', {
-                eventName: name,
-                hasMetadata: !!metadata,
-            });
-            throw new Error('App not initialized');
-        }
-        logging_1.debugLog.debug('API', 'Sending custom event', {
-            eventName: name,
-            hasMetadata: !!metadata,
-            metadataKeys: metadata ? Object.keys(metadata) : [],
-        });
         app.sendCustomEvent(name, metadata);
     }
     catch (error) {
-        logging_1.debugLog.error('API', 'Event tracking failed', { eventName: name, error, hasMetadata: !!metadata });
-        if (error instanceof Error &&
-            (error.message === 'App not initialized' || error.message.includes('validation failed'))) {
-            throw error;
-        }
+        utils_1.debugLog.error('API', 'Failed to send custom event', { eventName: name, error });
+        throw error;
     }
 };
 exports.event = event;
+/**
+ * Subscribe to events emitted by TraceLog
+ * @param event - Event name to listen to
+ * @param callback - Function to call when event is emitted
+ * @example
+ * // Listen for real-time events
+ * tracelog.on('realtime', (data) => {
+ *   console.log('Event tracked:', data.type, data.data);
+ * });
+ *
+ * // Listen for sent events
+ * tracelog.on('sent', (data) => {
+ *   console.log('Events sent:', data.eventCount);
+ * });
+ */
+const on = (event, callback) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
+    }
+    app.on(event, callback);
+};
+exports.on = on;
+/**
+ * Unsubscribe from events emitted by TraceLog
+ * @param event - Event name to stop listening to
+ * @param callback - The same function reference that was used in on()
+ * @example
+ * // Remove a specific listener
+ * tracelog.off('realtime', myCallback);
+ */
+const off = (event, callback) => {
+    if (!app) {
+        throw new Error('TraceLog not initialized. Please call init() first.');
+    }
+    app.off(event, callback);
+};
+exports.off = off;
 /**
  * Checks if the app has been initialized.
  * @returns true if the app is initialized, false otherwise
@@ -169,56 +132,48 @@ const isInitialized = () => {
     return app !== null;
 };
 exports.isInitialized = isInitialized;
-/**
- * Gets the current initialization status for debugging purposes.
- * @returns Object with detailed initialization state
- */
-const getInitializationStatus = () => {
-    return {
-        isInitialized: app !== null,
-        isInitializing: isInitializing,
-        hasInstance: app !== null,
-    };
-};
-exports.getInitializationStatus = getInitializationStatus;
 /**
  * Destroys the current app instance and cleans up resources.
+ * @throws {Error} If not initialized or already destroying
  */
-const destroy = () => {
+const destroy = async () => {
+    // Check if app was never initialized
+    if (!app) {
+        throw new Error('App not initialized');
+    }
+    // Prevent concurrent destroy operations
+    if (isDestroying) {
+        throw new Error('Destroy operation already in progress');
+    }
+    isDestroying = true;
     try {
-        logging_1.debugLog.info('API', 'Library cleanup initiated');
-        if (!app) {
-            logging_1.debugLog.warn('API', 'Cleanup called but Library was not initialized');
-            throw new Error('App not initialized');
-        }
-        app.destroy();
+        utils_1.debugLog.info('API', 'Destroying TraceLog instance');
+        await app.destroy();
         app = null;
         isInitializing = false;
-        logging_1.debugLog.info('API', 'Library cleanup completed successfully');
+        utils_1.debugLog.info('API', 'TraceLog destroyed successfully');
     }
     catch (error) {
-        logging_1.debugLog.error('API', 'Cleanup failed', { error, hadApp: !!app, wasInitializing: isInitializing });
+        // Force cleanup even if destroy fails
+        app = null;
+        isInitializing = false;
+        utils_1.debugLog.error('API', 'Error during destroy, forced cleanup', { error });
+        throw error;
+    }
+    finally {
+        isDestroying = false;
     }
 };
 exports.destroy = destroy;
-class TestBridge extends app_1.App {
-    isInitializing() {
-        return isInitializing;
+// Auto-inject testing bridge in development environments
+if (process.env.NODE_ENV === 'dev' && typeof window !== 'undefined') {
+    const injectTestingBridge = () => {
+        window.__traceLogBridge = new test_bridge_1.TestBridge(isInitializing, isDestroying);
+    };
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', injectTestingBridge);
     }
-}
-// Auto-inject testing bridge only in development/testing environments
-if (process.env.NODE_ENV === 'dev') {
-    if (typeof window !== 'undefined') {
-        // Wait for DOM to be ready before injecting
-        const injectTestingBridge = () => {
-            window.__traceLogBridge = new TestBridge();
-        };
-        // Inject immediately if DOM is ready, otherwise wait
-        if (document.readyState === 'loading') {
-            document.addEventListener('DOMContentLoaded', injectTestingBridge);
-        }
-        else {
-            injectTestingBridge();
-        }
+    else {
+        injectTestingBridge();
     }
 }

package/dist/cjs/app.constants.d.ts

@@ -1 +1,80 @@
-export { DEFAULT_SESSION_TIMEOUT_MS } from './constants';
+export declare const PERFORMANCE_CONFIG: {
+    readonly WEB_VITALS_THRESHOLDS: Record<import("./types").WebVitalType, number>;
+};
+export declare const DATA_PROTECTION: {
+    readonly PII_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+};
+export declare const ENGAGEMENT_THRESHOLDS: {
+    readonly LOW_ACTIVITY_EVENT_COUNT: 50;
+    readonly HIGH_ACTIVITY_EVENT_COUNT: 1000;
+    readonly MIN_EVENTS_FOR_DYNAMIC_CALCULATION: 100;
+    readonly MIN_EVENTS_FOR_TREND_ANALYSIS: 30;
+    readonly BOUNCE_RATE_SESSION_THRESHOLD: 1;
+    readonly MIN_ENGAGED_SESSION_DURATION_MS: number;
+    readonly MIN_SCROLL_DEPTH_ENGAGEMENT: 25;
+};
+export declare const SESSION_ANALYTICS: {
+    readonly INACTIVITY_TIMEOUT_MS: number;
+    readonly SHORT_SESSION_THRESHOLD_MS: number;
+    readonly MEDIUM_SESSION_THRESHOLD_MS: number;
+    readonly LONG_SESSION_THRESHOLD_MS: number;
+    readonly MAX_REALISTIC_SESSION_DURATION_MS: number;
+};
+export declare const DEVICE_ANALYTICS: {
+    readonly MOBILE_MAX_WIDTH: 768;
+    readonly TABLET_MAX_WIDTH: 1024;
+    readonly MOBILE_PERFORMANCE_FACTOR: 1.5;
+    readonly TABLET_PERFORMANCE_FACTOR: 1.2;
+};
+export declare const CONTENT_ANALYTICS: {
+    readonly MIN_TEXT_LENGTH_FOR_ANALYSIS: 10;
+    readonly MIN_CLICKS_FOR_HOT_ELEMENT: 10;
+    readonly MIN_SCROLL_COMPLETION_PERCENT: 80;
+    readonly MIN_TIME_ON_PAGE_FOR_READ_MS: number;
+};
+export declare const INSIGHT_THRESHOLDS: {
+    readonly SIGNIFICANT_CHANGE_PERCENT: 20;
+    readonly MAJOR_CHANGE_PERCENT: 50;
+    readonly MIN_EVENTS_FOR_INSIGHT: 100;
+    readonly MIN_SESSIONS_FOR_INSIGHT: 10;
+    readonly MIN_CORRELATION_STRENGTH: 0.7;
+    readonly LOW_ERROR_RATE_PERCENT: 1;
+    readonly HIGH_ERROR_RATE_PERCENT: 5;
+    readonly CRITICAL_ERROR_RATE_PERCENT: 10;
+};
+export declare const TEMPORAL_ANALYSIS: {
+    readonly SHORT_TERM_TREND_HOURS: 24;
+    readonly MEDIUM_TERM_TREND_DAYS: 7;
+    readonly LONG_TERM_TREND_DAYS: 30;
+    readonly MIN_DATA_POINTS_FOR_TREND: 5;
+    readonly WEEKLY_PATTERN_MIN_WEEKS: 4;
+    readonly DAILY_PATTERN_MIN_DAYS: 14;
+};
+export declare const SEGMENTATION_ANALYTICS: {
+    readonly MIN_SEGMENT_SIZE: 10;
+    readonly MIN_COHORT_SIZE: 5;
+    readonly COHORT_ANALYSIS_DAYS: readonly [1, 3, 7, 14, 30];
+    readonly MIN_FUNNEL_EVENTS: 20;
+};
+export declare const ANALYTICS_QUERY_LIMITS: {
+    readonly DEFAULT_EVENTS_LIMIT: 5;
+    readonly DEFAULT_SESSIONS_LIMIT: 5;
+    readonly DEFAULT_PAGES_LIMIT: 5;
+    readonly MAX_EVENTS_FOR_DEEP_ANALYSIS: 10000;
+    readonly MAX_TIME_RANGE_DAYS: 365;
+    readonly ANALYTICS_BATCH_SIZE: 1000;
+};
+export declare const ANOMALY_DETECTION: {
+    readonly ANOMALY_THRESHOLD_SIGMA: 2.5;
+    readonly STRONG_ANOMALY_THRESHOLD_SIGMA: 3;
+    readonly TRAFFIC_DROP_ALERT_PERCENT: -30;
+    readonly TRAFFIC_SPIKE_ALERT_PERCENT: 200;
+    readonly MIN_BASELINE_DAYS: 7;
+    readonly MIN_EVENTS_FOR_ANOMALY_DETECTION: 50;
+};
+export declare const SPECIAL_VALUES: {
+    readonly PAGE_URL_EXCLUDED: "excluded";
+    readonly PAGE_URL_UNKNOWN: "unknown";
+    readonly IPV6_IPV4_PREFIX: "::ffff:";
+};
+export declare const LOCAL_IP_ADDRESSES: readonly ["localhost", "127.0.0.1", "::1"];

package/dist/cjs/app.constants.js

@@ -1,5 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SESSION_TIMEOUT_MS = void 0;
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "DEFAULT_SESSION_TIMEOUT_MS", { enumerable: true, get: function () { return constants_1.DEFAULT_SESSION_TIMEOUT_MS; } });
+exports.LOCAL_IP_ADDRESSES = exports.SPECIAL_VALUES = exports.ANOMALY_DETECTION = exports.ANALYTICS_QUERY_LIMITS = exports.SEGMENTATION_ANALYTICS = exports.TEMPORAL_ANALYSIS = exports.INSIGHT_THRESHOLDS = exports.CONTENT_ANALYTICS = exports.DEVICE_ANALYTICS = exports.SESSION_ANALYTICS = exports.ENGAGEMENT_THRESHOLDS = exports.DATA_PROTECTION = exports.PERFORMANCE_CONFIG = void 0;
+// Solo importamos constantes con valor analítico real
+const performance_constants_1 = require("./constants/performance.constants");
+const error_constants_1 = require("./constants/error.constants");
+// ============================================================================
+// PERFORMANCE ANALYTICS CONSTANTS
+// ============================================================================
+exports.PERFORMANCE_CONFIG = {
+    WEB_VITALS_THRESHOLDS: performance_constants_1.WEB_VITALS_THRESHOLDS, // Umbrales de negocio para análisis de rendimiento
+};
+// ============================================================================
+// DATA PROTECTION CONSTANTS
+// ============================================================================
+exports.DATA_PROTECTION = {
+    PII_PATTERNS: error_constants_1.PII_PATTERNS, // Patrones para protección de datos sensibles
+};
+exports.ENGAGEMENT_THRESHOLDS = {
+    LOW_ACTIVITY_EVENT_COUNT: 50,
+    HIGH_ACTIVITY_EVENT_COUNT: 1000,
+    MIN_EVENTS_FOR_DYNAMIC_CALCULATION: 100,
+    MIN_EVENTS_FOR_TREND_ANALYSIS: 30,
+    BOUNCE_RATE_SESSION_THRESHOLD: 1, // Sessions with 1 page view = bounce
+    MIN_ENGAGED_SESSION_DURATION_MS: 30 * 1000,
+    MIN_SCROLL_DEPTH_ENGAGEMENT: 25, // 25% scroll depth for engagement
+};
+exports.SESSION_ANALYTICS = {
+    INACTIVITY_TIMEOUT_MS: 30 * 60 * 1000, // 30min for analytics (vs 15min client)
+    SHORT_SESSION_THRESHOLD_MS: 30 * 1000,
+    MEDIUM_SESSION_THRESHOLD_MS: 5 * 60 * 1000,
+    LONG_SESSION_THRESHOLD_MS: 30 * 60 * 1000,
+    MAX_REALISTIC_SESSION_DURATION_MS: 8 * 60 * 60 * 1000, // Filter outliers
+};
+exports.DEVICE_ANALYTICS = {
+    MOBILE_MAX_WIDTH: 768,
+    TABLET_MAX_WIDTH: 1024,
+    MOBILE_PERFORMANCE_FACTOR: 1.5, // Mobile typically 1.5x slower
+    TABLET_PERFORMANCE_FACTOR: 1.2,
+};
+exports.CONTENT_ANALYTICS = {
+    MIN_TEXT_LENGTH_FOR_ANALYSIS: 10,
+    MIN_CLICKS_FOR_HOT_ELEMENT: 10, // Popular element threshold
+    MIN_SCROLL_COMPLETION_PERCENT: 80, // Page consumption threshold
+    MIN_TIME_ON_PAGE_FOR_READ_MS: 15 * 1000,
+};
+exports.INSIGHT_THRESHOLDS = {
+    SIGNIFICANT_CHANGE_PERCENT: 20,
+    MAJOR_CHANGE_PERCENT: 50,
+    MIN_EVENTS_FOR_INSIGHT: 100,
+    MIN_SESSIONS_FOR_INSIGHT: 10,
+    MIN_CORRELATION_STRENGTH: 0.7, // Strong correlation threshold
+    LOW_ERROR_RATE_PERCENT: 1,
+    HIGH_ERROR_RATE_PERCENT: 5,
+    CRITICAL_ERROR_RATE_PERCENT: 10,
+};
+exports.TEMPORAL_ANALYSIS = {
+    SHORT_TERM_TREND_HOURS: 24,
+    MEDIUM_TERM_TREND_DAYS: 7,
+    LONG_TERM_TREND_DAYS: 30,
+    MIN_DATA_POINTS_FOR_TREND: 5,
+    WEEKLY_PATTERN_MIN_WEEKS: 4,
+    DAILY_PATTERN_MIN_DAYS: 14,
+};
+exports.SEGMENTATION_ANALYTICS = {
+    MIN_SEGMENT_SIZE: 10,
+    MIN_COHORT_SIZE: 5,
+    COHORT_ANALYSIS_DAYS: [1, 3, 7, 14, 30],
+    MIN_FUNNEL_EVENTS: 20,
+};
+exports.ANALYTICS_QUERY_LIMITS = {
+    DEFAULT_EVENTS_LIMIT: 5,
+    DEFAULT_SESSIONS_LIMIT: 5,
+    DEFAULT_PAGES_LIMIT: 5,
+    MAX_EVENTS_FOR_DEEP_ANALYSIS: 10000,
+    MAX_TIME_RANGE_DAYS: 365,
+    ANALYTICS_BATCH_SIZE: 1000, // For historical analysis
+};
+exports.ANOMALY_DETECTION = {
+    ANOMALY_THRESHOLD_SIGMA: 2.5,
+    STRONG_ANOMALY_THRESHOLD_SIGMA: 3.0,
+    TRAFFIC_DROP_ALERT_PERCENT: -30,
+    TRAFFIC_SPIKE_ALERT_PERCENT: 200,
+    MIN_BASELINE_DAYS: 7,
+    MIN_EVENTS_FOR_ANOMALY_DETECTION: 50,
+};
+exports.SPECIAL_VALUES = {
+    PAGE_URL_EXCLUDED: 'excluded',
+    PAGE_URL_UNKNOWN: 'unknown',
+    IPV6_IPV4_PREFIX: '::ffff:',
+};
+exports.LOCAL_IP_ADDRESSES = ['localhost', '127.0.0.1', '::1'];

package/dist/cjs/app.d.ts

@@ -1,59 +1,44 @@
 import { EventManager } from './managers/event.manager';
-import { AppConfig } from './types/config.types';
 import { StateManager } from './managers/state.manager';
 import { SessionHandler } from './handlers/session.handler';
 import { PageViewHandler } from './handlers/page-view.handler';
 import { ClickHandler } from './handlers/click.handler';
 import { ScrollHandler } from './handlers/scroll.handler';
+import { AppConfig, EmitterCallback, EmitterMap } from './types';
 import { GoogleAnalyticsIntegration } from './integrations/google-analytics.integration';
 import { StorageManager } from './managers/storage.manager';
 import { PerformanceHandler } from './handlers/performance.handler';
 import { ErrorHandler } from './handlers/error.handler';
-import { NetworkHandler } from './handlers/network.handler';
+/**
+ * Main application class for TraceLog analytics
+ * Orchestrates event tracking, session management, and integrations
+ */
 export declare class App extends StateManager {
-    protected isInitialized: boolean;
-    protected googleAnalytics: GoogleAnalyticsIntegration | null;
-    protected storageManager: StorageManager;
-    protected eventManager: EventManager;
-    protected sessionHandler: SessionHandler;
-    protected pageViewHandler: PageViewHandler;
-    protected clickHandler: ClickHandler;
-    protected scrollHandler: ScrollHandler;
-    protected performanceHandler: PerformanceHandler;
-    protected errorHandler: ErrorHandler;
-    protected networkHandler: NetworkHandler;
-    protected suppressNextScrollTimer: number | null;
-    /**
-     * Returns the initialization status of the app
-     * @returns true if the app is fully initialized, false otherwise
-     */
+    private isInitialized;
+    private suppressNextScrollTimer;
+    private readonly emitter;
+    protected managers: {
+        storage?: StorageManager;
+        event?: EventManager;
+    };
+    protected handlers: {
+        session?: SessionHandler;
+        pageView?: PageViewHandler;
+        click?: ClickHandler;
+        scroll?: ScrollHandler;
+        performance?: PerformanceHandler;
+        error?: ErrorHandler;
+    };
+    protected integrations: {
+        googleAnalytics?: GoogleAnalyticsIntegration;
+    };
     get initialized(): boolean;
     init(appConfig: AppConfig): Promise<void>;
-    /**
-     * Validates that the app is ready to initialize with the provided config
-     * This is a lightweight runtime validation layer that ensures the app receives proper config
-     * @param appConfig - The validated and normalized configuration
-     * @throws {ProjectIdValidationError} If project ID is invalid at runtime
-     */
-    private validateAppReadiness;
     sendCustomEvent(name: string, metadata?: Record<string, unknown>): void;
-    destroy(): void;
-    private setState;
-    private setApiUrl;
-    private setConfig;
-    private setUserId;
-    private setDevice;
-    private setPageUrl;
-    private setIntegrations;
-    private initHandlers;
-    private initStorage;
-    private setEventManager;
-    private initSessionHandler;
-    private initPageViewHandler;
-    private onPageViewTrack;
-    private initClickHandler;
-    private initScrollHandler;
-    private initPerformanceHandler;
-    private initErrorHandler;
-    private initNetworkHandler;
+    on<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    off<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    destroy(force?: boolean): Promise<void>;
+    private setupState;
+    private setupIntegrations;
+    private initializeHandlers;
 }