@tracelog/lib 0.1.0 → 0.2.1

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

@@ -1,61 +1,82 @@
 import { EventData } from '../types';
+import { Emitter } from '../utils';
 import { StateManager } from './state.manager';
 import { StorageManager } from './storage.manager';
 import { GoogleAnalyticsIntegration } from '../integrations/google-analytics.integration';
+/**
+ * EventManager - Core event tracking and queue management
+ *
+ * Responsibilities:
+ * - Track user events (clicks, scrolls, page views, custom events)
+ * - Queue events and batch send them to the analytics API
+ * - Handle deduplication of similar events
+ * - Manage event sending intervals and retry logic
+ * - Integrate with Google Analytics when configured
+ */
 export declare class EventManager extends StateManager {
     private readonly googleAnalytics;
-    private readonly samplingManager;
-    private readonly tagsManager;
     private readonly dataSender;
-    private readonly storageManager;
+    private readonly emitter;
     private eventsQueue;
-    private lastEvent;
-    private eventsQueueIntervalId;
-    private intervalActive;
-    private failureCount;
-    private readonly MAX_FAILURES;
-    private circuitOpen;
-    private circuitOpenTime;
-    private backoffDelay;
-    private circuitResetTimeoutId;
-    private readonly eventFingerprints;
-    private readonly PERSISTENCE_KEY;
-    constructor(storeManager: StorageManager, googleAnalytics?: GoogleAnalyticsIntegration | null);
-    track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, session_end_reason, session_start_recovered, }: Partial<EventData>): void;
+    private lastEventFingerprint;
+    private lastEventTime;
+    private sendIntervalId;
+    constructor(storeManager: StorageManager, googleAnalytics?: GoogleAnalyticsIntegration | null, emitter?: Emitter | null);
+    /**
+     * Recovers persisted events from localStorage
+     * Should be called after initialization to recover any events that failed to send
+     */
+    recoverPersistedEvents(): Promise<void>;
+    /**
+     * Track user events with automatic deduplication and queueing
+     */
+    track({ type, page_url, from_page_url, scroll_data, click_data, custom_event, web_vitals, error_data, session_end_reason, session_start_recovered, }: Partial<EventData>): void;
     stop(): void;
-    private processAndSend;
-    private trackGoogleAnalyticsEvent;
-    private initEventsQueueInterval;
+    /**
+     * Flush all queued events immediately (async)
+     */
     flushImmediately(): Promise<boolean>;
+    /**
+     * Flush all queued events immediately (sync)
+     */
     flushImmediatelySync(): boolean;
+    /**
+     * Queue management and sending intervals
+     */
     getQueueLength(): number;
-    private sendEventsQueue;
-    private buildEventsPayload;
-    private clearQueueInterval;
-    private getEventFingerprint;
-    private isDuplicatedEvent;
+    private clearSendInterval;
     /**
-     * Cleans up old fingerprints to prevent memory leaks
+     * Shared flush implementation for both sync and async modes
      */
-    private cleanupOldFingerprints;
+    private flushEvents;
     /**
-     * Opens the circuit breaker with time-based recovery and event persistence
+     * Send queued events to the API
      */
-    private openCircuitBreaker;
+    private sendEventsQueue;
     /**
-     * Resets the circuit breaker and attempts to restore persisted events
+     * Build the payload for sending events to the API
+     * Includes basic deduplication and sorting
      */
-    private resetCircuitBreaker;
+    private buildEventsPayload;
     /**
-     * Persists current events queue to localStorage for recovery
+     * Helper methods for event processing
      */
-    private persistEventsToStorage;
+    private buildEventPayload;
+    private isEventExcluded;
+    private isDuplicateEvent;
+    private createEventFingerprint;
+    private createEventSignature;
+    private addToQueue;
+    private startSendInterval;
+    private handleGoogleAnalyticsIntegration;
+    private shouldSample;
+    private removeProcessedEvents;
     /**
-     * Restores events from localStorage if available and not expired
+     * Emit event for external listeners
      */
-    private restoreEventsFromStorage;
+    private emitEvent;
     /**
-     * Clears persisted events from localStorage
+     * Emit events queue for external listeners
      */
-    private clearPersistedEvents;
+    private emitEventsQueue;
 }