@tracelog/lib 0.0.8 → 0.2.0

package/dist/cjs/test-bridge.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestBridge = void 0;
+const app_1 = require("./app");
+const utils_1 = require("./utils");
+/**
+ * Test bridge for E2E testing
+ */
+class TestBridge extends app_1.App {
+    constructor(isInitializing, isDestroying) {
+        super();
+        this._isDestroying = false;
+        this._isInitializing = isInitializing;
+        this._isDestroying = isDestroying;
+    }
+    isInitializing() {
+        return this._isInitializing;
+    }
+    sendCustomEvent(name, data) {
+        this.ensureInitialized();
+        super.sendCustomEvent(name, data);
+    }
+    getSessionData() {
+        return {
+            id: this.get('sessionId'),
+            isActive: !!this.get('sessionId'),
+            timeout: this.get('config')?.sessionTimeout ?? 15 * 60 * 1000,
+        };
+    }
+    setSessionTimeout(timeout) {
+        const config = this.get('config');
+        if (config) {
+            const { config: normalizedConfig } = (0, utils_1.normalizeConfig)({ ...config, sessionTimeout: timeout });
+            this.set('config', normalizedConfig);
+        }
+    }
+    getQueueLength() {
+        return this.managers.event?.getQueueLength() ?? 0;
+    }
+    forceInitLock(enabled = true) {
+        this._isInitializing = enabled;
+    }
+    get(key) {
+        return super.get(key);
+    }
+    // Manager accessors
+    getStorageManager() {
+        return this.safeAccess(this.managers?.storage);
+    }
+    getEventManager() {
+        return this.safeAccess(this.managers?.event);
+    }
+    // Handler accessors
+    getSessionHandler() {
+        return this.safeAccess(this.handlers?.session);
+    }
+    getPageViewHandler() {
+        return this.safeAccess(this.handlers?.pageView);
+    }
+    getClickHandler() {
+        return this.safeAccess(this.handlers?.click);
+    }
+    getScrollHandler() {
+        return this.safeAccess(this.handlers?.scroll);
+    }
+    getPerformanceHandler() {
+        return this.safeAccess(this.handlers?.performance);
+    }
+    getErrorHandler() {
+        return this.safeAccess(this.handlers?.error);
+    }
+    // Integration accessors
+    getGoogleAnalytics() {
+        return this.safeAccess(this.integrations?.googleAnalytics);
+    }
+    async destroy() {
+        this.ensureInitialized();
+        this.ensureNotDestroying();
+        this._isDestroying = true;
+        try {
+            await super.destroy();
+        }
+        finally {
+            this._isDestroying = false;
+        }
+    }
+    /**
+     * Helper to safely access managers/handlers and convert undefined to null
+     */
+    safeAccess(value) {
+        return value ?? null;
+    }
+    /**
+     * Ensures the app is initialized, throws if not
+     */
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('App not initialized');
+        }
+    }
+    /**
+     * Ensures destroy operation is not in progress, throws if it is
+     */
+    ensureNotDestroying() {
+        if (this._isDestroying) {
+            throw new Error('Destroy operation already in progress');
+        }
+    }
+}
+exports.TestBridge = TestBridge;

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

@@ -2,20 +2,35 @@
  * Special project IDs for testing and development
  *
  * Both automatically force mode: 'debug' but differ in HTTP behavior:
- * - HttpSkip: NO network calls (pure offline testing)
- * - HttpLocal: Makes network calls to local server (integration testing)
+ * - Skip: NO network calls (pure offline testing)
+ * - Localhost: Makes network calls to local server (integration testing)
  */
 export declare enum SpecialProjectId {
     /**
+     * Value: 'skip'
+     *
      * Skips ALL HTTP calls - no config fetch, no event sending
      * Uses default local config, forces debug mode
      * Perfect for pure offline E2E testing
+     *
+     * @example
+     * await TraceLog.init({ id: SpecialProjectId.Skip });
+     * // or
+     * await TraceLog.init({ id: 'skip' });
      */
-    HttpSkip = "http-skip",
+    Skip = "skip",
     /**
-     * Makes HTTP calls to window.location.origin instead of production API
-     * Fetches config and sends events to local server, forces debug mode
+     * Value: 'localhost:' (used as prefix)
+     *
+     * Makes HTTP calls to local development server
+     * Must specify full address: 'localhost:PORT' (e.g., 'localhost:3000')
+     * Converts to http://localhost:PORT/config for requests
+     * Requires origin to be in ALLOWED_ORIGINS list, forces debug mode
      * Perfect for local development with running middleware
+     *
+     * @example
+     * await TraceLog.init({ id: 'localhost:3000' });
+     * // Makes requests to: http://localhost:3000/config
      */
-    HttpLocal = "http-local"
+    Localhost = "localhost:"
 }

package/dist/cjs/types/api.types.js

@@ -5,21 +5,36 @@ exports.SpecialProjectId = void 0;
  * Special project IDs for testing and development
  *
  * Both automatically force mode: 'debug' but differ in HTTP behavior:
- * - HttpSkip: NO network calls (pure offline testing)
- * - HttpLocal: Makes network calls to local server (integration testing)
+ * - Skip: NO network calls (pure offline testing)
+ * - Localhost: Makes network calls to local server (integration testing)
  */
 var SpecialProjectId;
 (function (SpecialProjectId) {
     /**
+     * Value: 'skip'
+     *
      * Skips ALL HTTP calls - no config fetch, no event sending
      * Uses default local config, forces debug mode
      * Perfect for pure offline E2E testing
+     *
+     * @example
+     * await TraceLog.init({ id: SpecialProjectId.Skip });
+     * // or
+     * await TraceLog.init({ id: 'skip' });
      */
-    SpecialProjectId["HttpSkip"] = "http-skip";
+    SpecialProjectId["Skip"] = "skip";
     /**
-     * Makes HTTP calls to window.location.origin instead of production API
-     * Fetches config and sends events to local server, forces debug mode
+     * Value: 'localhost:' (used as prefix)
+     *
+     * Makes HTTP calls to local development server
+     * Must specify full address: 'localhost:PORT' (e.g., 'localhost:3000')
+     * Converts to http://localhost:PORT/config for requests
+     * Requires origin to be in ALLOWED_ORIGINS list, forces debug mode
      * Perfect for local development with running middleware
+     *
+     * @example
+     * await TraceLog.init({ id: 'localhost:3000' });
+     * // Makes requests to: http://localhost:3000/config
      */
-    SpecialProjectId["HttpLocal"] = "http-local";
+    SpecialProjectId["Localhost"] = "localhost:";
 })(SpecialProjectId || (exports.SpecialProjectId = SpecialProjectId = {}));

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

@@ -1,103 +1,41 @@
 import { MetadataType } from './common.types';
 import { TagConfig } from './tag.types';
 import { Mode } from './mode.types';
-export type Config = ApiConfig & AppConfig;
-export interface ApiConfig {
-    /**
-     * Logging mode for the library.
-     * - 'qa': Shows client-facing logs only (INFO, CLIENT_WARN, CLIENT_ERROR)
-     * - 'debug': Shows all logs including internal library errors
-     */
-    mode?: Mode;
-    /**
-     * Sampling rate as a percentage (0-1) to control how many events are sent.
-     * A value of 1 means all events are sent, while 0.5 means only half of events are sent.
-     */
-    samplingRate?: number;
-    /**
-     * Array of tag configurations for categorizing and filtering events.
-     * Tags help organize and segment tracking data for analysis.
-     */
+export type Config = AppConfig & ExclusiveApiConfig;
+export type ApiConfig = SharedConfig & ExclusiveApiConfig;
+export type SharedConfig = Pick<AppConfig, 'mode' | 'samplingRate' | 'excludedUrlPaths'>;
+export interface ExclusiveApiConfig {
+    /** Tag definitions used to categorize tracked events. */
     tags?: TagConfig[];
-    /**
-     * Array of URL path patterns to exclude from tracking.
-     * Events will not be sent for pages matching these patterns.
-     */
-    excludedUrlPaths?: string[];
-    /**
-     * Flag to indicate if IP addresses should be excluded from tracking.
-     * When true, IP addresses will not be collected or sent with events.
-     * This is useful for privacy compliance and reducing data exposure.
-     */
+    /** Determines if IP address is excluded from tracking. */
     ipExcluded?: boolean;
 }
 export interface AppConfig {
-    /**
-     * Unique project identifier.
-     */
+    /** Project identifier used for tracing. */
     id: string;
-    /**
-     * Session timeout in milliseconds. After this period of inactivity,
-     * a new session will be started for subsequent events.
-     *
-     * **Timeout Guidelines:**
-     * - **15 minutes (default)**: Recommended for most applications, aligns with security best practices
-     * - **30 minutes**: Standard for content-heavy sites (matches Google Analytics default)
-     * - **45-60 minutes**: Consider for sites with long-form content, videos, or documentation
-     * - **5-10 minutes**: Use for security-sensitive applications requiring frequent re-authentication
-     *
-     * **Impact on Analytics:**
-     * - Shorter timeouts = Higher session count, higher bounce rate, potentially lower conversion rates
-     * - Longer timeouts = Lower session count, more accurate user journey tracking, better conversion attribution
-     *
-     * **When to Adjust:**
-     * - Match your application's auto-logout timeout if applicable
-     * - Increase for content where users frequently pause (tutorials, long articles, videos)
-     * - Decrease for applications with sensitive data or frequent security requirements
-     * - Monitor bounce rates and conversion funnels when changing this value
-     *
-     * @default 900000 (15 minutes)
-     * @min 30000 (30 seconds)
-     * @max 86400000 (24 hours)
-     */
+    /** Session inactivity timeout in milliseconds. @default 900000 */
     sessionTimeout?: number;
-    /**
-     * Metadata that will be automatically attached to all tracking events.
-     * These key-value pairs provide additional context for every event sent.
-     */
+    /** Metadata appended to every tracked event. */
     globalMetadata?: Record<string, MetadataType>;
-    /**
-     * CSS selectors for custom scroll containers. Can be a single selector string
-     * or an array of selectors. Used to track scroll events within specific elements
-     * instead of the default window scroll.
-     */
+    /** Selectors defining custom scroll containers to monitor. */
     scrollContainerSelectors?: string | string[];
-    /**
-     * Allow HTTP requests to be made. This is useful for testing and development.
-     */
+    /** Enables HTTP requests for testing and development flows. */
     allowHttp?: boolean;
-    /**
-     * Array of query parameters to be removed from the URL.
-     */
+    /** Query parameters to remove before tracking URLs. */
     sensitiveQueryParams?: string[];
-    /**
-     * Sampling rate for error events (0-1).
-     * Controls how many error and network error events are captured.
-     * @default 0.1 for production, 1.0 for qa/debug mode
-     */
+    /** Error event sampling rate between 0 and 1. */
     errorSampling?: number;
-    /**
-     * Optional integrations configuration.
-     */
+    /** Logging mode controlling verbosity of client logs. */
+    mode?: Mode;
+    /** Event sampling rate between 0 and 1. */
+    samplingRate?: number;
+    /** URL path patterns that should be ignored by tracking. */
+    excludedUrlPaths?: string[];
+    /** Optional configuration for third-party integrations. */
     integrations?: {
-        /**
-         * Google Analytics integration configuration.
-         */
+        /** Google Analytics integration options. */
         googleAnalytics?: {
-            /**
-             * Google Analytics measurement ID.
-             * Required for initializing the Google Analytics integration.
-             */
+            /** Required measurement ID for Google Analytics. */
             measurementId: string;
         };
     };

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

@@ -0,0 +1,11 @@
+import { EventData } from './event.types';
+import { BaseEventsQueueDto } from './queue.types';
+export type EmitterCallback<T = any> = (data: T) => void;
+export declare enum EmitterEvent {
+    EVENT = "event",
+    QUEUE = "queue"
+}
+export interface EmitterMap {
+    [EmitterEvent.EVENT]: EventData;
+    [EmitterEvent.QUEUE]: BaseEventsQueueDto;
+}

package/dist/cjs/types/emitter.types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterEvent = void 0;
+var EmitterEvent;
+(function (EmitterEvent) {
+    EmitterEvent["EVENT"] = "event";
+    EmitterEvent["QUEUE"] = "queue";
+})(EmitterEvent || (exports.EmitterEvent = EmitterEvent = {}));

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

@@ -40,12 +40,7 @@ export interface ClickData {
     ariaLabel?: string;
     dataAttributes?: Record<string, string>;
 }
-export interface ClickCoordinates {
-    x: number;
-    y: number;
-    relativeX: number;
-    relativeY: number;
-}
+export type ClickCoordinates = Pick<ClickData, 'x' | 'y' | 'relativeX' | 'relativeY'>;
 export interface ClickTrackingElementData {
     element: HTMLElement;
     name: string;
@@ -62,11 +57,9 @@ export interface WebVitalsData {
 export interface ErrorData {
     type: ErrorType;
     message: string;
-    method?: string;
-    url?: string;
-    status?: number;
-    statusText?: string;
-    duration?: number;
+    filename?: string;
+    line?: number;
+    column?: number;
 }
 export interface UTM {
     source?: string;
@@ -82,6 +75,10 @@ export interface PageViewData {
     search?: string;
     hash?: string;
 }
+export interface VitalSample {
+    type: WebVitalType;
+    value: number;
+}
 export interface EventData {
     type: EventType;
     page_url: string;

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

@@ -2,12 +2,14 @@ export * from './api.types';
 export * from './common.types';
 export * from './config.types';
 export * from './device.types';
+export * from './emitter.types';
 export * from './event.types';
 export * from './log.types';
 export * from './mode.types';
 export * from './queue.types';
+export * from './session.types';
 export * from './state.types';
 export * from './tag.types';
+export * from './test-bridge.types';
 export * from './validation-error.types';
-export * from './web-vitals.types';
 export * from './window.types';

package/dist/cjs/types/index.js

@@ -18,12 +18,14 @@ __exportStar(require("./api.types"), exports);
 __exportStar(require("./common.types"), exports);
 __exportStar(require("./config.types"), exports);
 __exportStar(require("./device.types"), exports);
+__exportStar(require("./emitter.types"), exports);
 __exportStar(require("./event.types"), exports);
 __exportStar(require("./log.types"), exports);
 __exportStar(require("./mode.types"), exports);
 __exportStar(require("./queue.types"), exports);
+__exportStar(require("./session.types"), exports);
 __exportStar(require("./state.types"), exports);
 __exportStar(require("./tag.types"), exports);
+__exportStar(require("./test-bridge.types"), exports);
 __exportStar(require("./validation-error.types"), exports);
-__exportStar(require("./web-vitals.types"), exports);
 __exportStar(require("./window.types"), exports);

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

@@ -20,4 +20,5 @@ export interface PersistedQueueData {
     events: BaseEventsQueueDto['events'];
     timestamp: number;
     global_metadata?: BaseEventsQueueDto['global_metadata'];
+    fallbackMode?: boolean;
 }

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

@@ -1,65 +1 @@
 export type SessionEndReason = 'inactivity' | 'page_unload' | 'manual_stop' | 'orphaned_cleanup' | 'tab_closed';
-export interface SessionEndConfig {
-    enablePageUnloadHandlers: boolean;
-    syncTimeoutMs: number;
-    maxRetries: number;
-    debugMode: boolean;
-}
-export interface SessionEndResult {
-    success: boolean;
-    reason: SessionEndReason;
-    timestamp: number;
-    eventsFlushed: number;
-    method: 'async' | 'sync';
-}
-export interface SessionEndStats {
-    totalSessionEnds: number;
-    successfulEnds: number;
-    failedEnds: number;
-    duplicatePrevented: number;
-    reasonCounts: Record<SessionEndReason, number>;
-}
-export interface CrossTabSessionConfig {
-    tabHeartbeatIntervalMs: number;
-    tabElectionTimeoutMs: number;
-    debugMode: boolean;
-}
-export interface TabInfo {
-    id: string;
-    lastHeartbeat: number;
-    isLeader: boolean;
-    sessionId: string;
-    startTime: number;
-}
-export interface CrossTabMessage {
-    type: 'heartbeat' | 'session_start' | 'session_end' | 'tab_closing' | 'election_request' | 'election_response';
-    tabId: string;
-    sessionId?: string;
-    timestamp: number;
-    data?: Record<string, unknown>;
-}
-export interface SessionRecoveryConfig {
-    recoveryWindowMs: number;
-    maxRecoveryAttempts: number;
-    contextPreservation: boolean;
-}
-export interface SessionContext {
-    sessionId: string;
-    startTime: number;
-    lastActivity: number;
-    tabCount: number;
-    recoveryAttempts: number;
-    metadata?: Record<string, unknown>;
-}
-export interface RecoveryAttempt {
-    sessionId: string;
-    timestamp: number;
-    attempt: number;
-    context: SessionContext;
-}
-export interface SessionHealth {
-    recoveryAttempts: number;
-    sessionTimeouts: number;
-    crossTabConflicts: number;
-    lastHealthCheck: number;
-}

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

@@ -9,4 +9,5 @@ export interface State {
     pageUrl: string;
     hasStartSession: boolean;
     suppressNextScroll: boolean;
+    scrollEventCount?: number;
 }

package/dist/cjs/types/test-bridge.types.d.ts

@@ -0,0 +1,38 @@
+import { ClickHandler } from '@/handlers/click.handler';
+import { ErrorHandler } from '@/handlers/error.handler';
+import { PageViewHandler } from '@/handlers/page-view.handler';
+import { PerformanceHandler } from '@/handlers/performance.handler';
+import { ScrollHandler } from '@/handlers/scroll.handler';
+import { SessionHandler } from '@/handlers/session.handler';
+import { GoogleAnalyticsIntegration } from '@/integrations/google-analytics.integration';
+import { EventManager } from '@/managers/event.manager';
+import { StorageManager as TraceLogStorageManager } from '@/managers/storage.manager';
+import { AppConfig } from './config.types';
+import { State } from './state.types';
+/**
+ * Testing bridge interface for E2E tests
+ * Only available when NODE_ENV=dev
+ */
+export interface TraceLogTestBridge {
+    readonly initialized: boolean;
+    init(config: AppConfig): Promise<void>;
+    destroy(): Promise<void>;
+    isInitializing(): boolean;
+    sendCustomEvent(name: string, data?: Record<string, unknown>): void;
+    on(event: string, callback: (data: any) => void): void;
+    off(event: string, callback: (data: any) => void): void;
+    getSessionData(): Record<string, unknown> | null;
+    setSessionTimeout(timeout: number): void;
+    getQueueLength(): number;
+    forceInitLock(enabled?: boolean): void;
+    get<T extends keyof State>(key: T): State[T];
+    getStorageManager(): TraceLogStorageManager | null;
+    getEventManager(): EventManager | null;
+    getSessionHandler(): SessionHandler | null;
+    getPageViewHandler(): PageViewHandler | null;
+    getClickHandler(): ClickHandler | null;
+    getScrollHandler(): ScrollHandler | null;
+    getPerformanceHandler(): PerformanceHandler | null;
+    getErrorHandler(): ErrorHandler | null;
+    getGoogleAnalytics(): GoogleAnalyticsIntegration | null;
+}

package/dist/cjs/types/validation-error.types.d.ts

@@ -40,3 +40,10 @@ export declare class SamplingRateValidationError extends TraceLogValidationError
 export declare class IntegrationValidationError extends TraceLogValidationError {
     constructor(message: string, layer?: 'config' | 'app' | 'runtime');
 }
+/**
+ * Thrown when initialization exceeds the maximum allowed timeout
+ */
+export declare class InitializationTimeoutError extends TraceLogValidationError {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number, layer?: 'config' | 'app' | 'runtime');
+}

package/dist/cjs/types/validation-error.types.js

@@ -4,7 +4,7 @@
  * Provides better error handling and consistency across validation layers
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationValidationError = exports.SamplingRateValidationError = exports.SessionTimeoutValidationError = exports.AppConfigValidationError = exports.ProjectIdValidationError = exports.TraceLogValidationError = void 0;
+exports.InitializationTimeoutError = exports.IntegrationValidationError = exports.SamplingRateValidationError = exports.SessionTimeoutValidationError = exports.AppConfigValidationError = exports.ProjectIdValidationError = exports.TraceLogValidationError = void 0;
 /**
  * Base class for all TraceLog validation errors
  */
@@ -66,3 +66,13 @@ class IntegrationValidationError extends TraceLogValidationError {
     }
 }
 exports.IntegrationValidationError = IntegrationValidationError;
+/**
+ * Thrown when initialization exceeds the maximum allowed timeout
+ */
+class InitializationTimeoutError extends TraceLogValidationError {
+    constructor(message, timeoutMs, layer = 'runtime') {
+        super(message, 'INITIALIZATION_TIMEOUT', layer);
+        this.timeoutMs = timeoutMs;
+    }
+}
+exports.InitializationTimeoutError = InitializationTimeoutError;

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

@@ -1,11 +1,4 @@
-import type { App } from '../app';
-/**
- * Testing bridge interface for E2E tests
- * Only available when NODE_ENV=dev
- */
-export interface TraceLogTestBridge extends App {
-    isInitializing(): boolean;
-}
+import { TraceLogTestBridge } from './test-bridge.types';
 declare global {
     interface Window {
         /**

package/dist/cjs/utils/data/uuid.utils.d.ts

@@ -1,5 +1,5 @@
 /**
- * Generates a RFC4122 compliant UUID v4
+ * Generates a RFC4122 compliant UUID v4 using native crypto API with fallback
  * @returns A UUID string
  */
 export declare const generateUUID: () => string;

package/dist/cjs/utils/data/uuid.utils.js

@@ -1,18 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUUID = void 0;
-const logging_1 = require("../logging");
 /**
- * Generates a RFC4122 compliant UUID v4
+ * Generates a RFC4122 compliant UUID v4 using native crypto API with fallback
  * @returns A UUID string
  */
 const generateUUID = () => {
-    const uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    // Use native crypto.randomUUID() if available (modern browsers)
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback for older browsers
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
         const r = (Math.random() * 16) | 0;
         const v = c === 'x' ? r : (r & 0x3) | 0x8;
         return v.toString(16);
     });
-    logging_1.debugLog.verbose('UUIDUtils', 'Generated new UUID', { uuid });
-    return uuid;
 };
 exports.generateUUID = generateUUID;

package/dist/cjs/utils/emitter.utils.d.ts

@@ -0,0 +1,8 @@
+import { EmitterCallback, EmitterMap } from '@/types';
+export declare class Emitter {
+    private readonly listeners;
+    on<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    off<K extends keyof EmitterMap>(event: K, callback: EmitterCallback<EmitterMap[K]>): void;
+    emit<K extends keyof EmitterMap>(event: K, data: EmitterMap[K]): void;
+    removeAllListeners(): void;
+}

package/dist/cjs/utils/emitter.utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+class Emitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+        }
+        this.listeners.get(event).push(callback);
+    }
+    off(event, callback) {
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index > -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    }
+    emit(event, data) {
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            callbacks.forEach((callback) => callback(data));
+        }
+    }
+    removeAllListeners() {
+        this.listeners.clear();
+    }
+}
+exports.Emitter = Emitter;