@levi123/trackers 4.0.0-dev.0

package/dist/esm/index.mjs

@@ -0,0 +1,402 @@
+"use client"
+class DebugTrackers {
+    constructor(enableLog) {
+        this.enableLog = !!enableLog;
+    }
+    log(message, ...args) {
+        this.enableLog && console.log(message, ...args);
+    }
+    warn(message, ...args) {
+        this.enableLog && console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.enableLog && console.error(message, ...args);
+    }
+}
+const debugTrackers = new DebugTrackers();
+
+// ----- Enums -----
+var ITrackingEvent;
+(function (ITrackingEvent) {
+    ITrackingEvent["PAGE_LOAD"] = "pageLoad";
+    ITrackingEvent["CLICK"] = "click";
+    ITrackingEvent["PERFORMANCE"] = "performance";
+    ITrackingEvent["PERFORMANCE_ENTRY"] = "performanceEntry";
+    ITrackingEvent["SCROLL"] = "scroll";
+    ITrackingEvent["MANUAL_CLICK"] = "manualClick";
+})(ITrackingEvent || (ITrackingEvent = {}));
+
+class GXTrackingSDK {
+    constructor() {
+        this.config = {
+            events: [ITrackingEvent.PAGE_LOAD, ITrackingEvent.CLICK],
+            workerTimeout: 5000,
+        };
+        this.isInitialized = false;
+        this.eventWorker = null;
+        this.callbackWorker = null;
+        this.callbacks = {};
+        this.workerStatus = {
+            eventWorker: 'idle',
+            callbackWorker: 'idle',
+        };
+        this.perEventCallbacks = new Map();
+        // Private event handlers
+        this.handlePageLoad = () => {
+            this.trackEvent(ITrackingEvent.PAGE_LOAD, {
+                timestamp: Date.now(),
+                url: window.location.href,
+            });
+        };
+        this.handleClick = (e) => {
+            const target = e.target;
+            if (target.tagName !== 'SCRIPT' && target.tagName !== 'STYLE')
+                return;
+            this.trackEvent(ITrackingEvent.CLICK, {
+                target: target.tagName,
+                targetId: target.id || '',
+                targetClass: target.className || '',
+                x: e.clientX,
+                y: e.clientY,
+                timestamp: Date.now(),
+            });
+        };
+        if (typeof window !== 'undefined' && !window.Worker) {
+            debugTrackers.warn('Web Worker not supported. Falling back to main thread.');
+            return;
+        }
+    }
+    init(userConfig = {}) {
+        if (this.isInitialized) {
+            debugTrackers.warn('SDK already initialized');
+            return;
+        }
+        // Merge config
+        Object.assign(this.config, userConfig);
+        debugTrackers.log('🚀 GXTrackingSDK initialized with config:', this.config);
+        // Initialize workers
+        this.initWorkers();
+        const handleStartTracking = () => {
+            setTimeout(() => {
+                this.isInitialized = true;
+                this.startTracking();
+                debugTrackers.log('✅ All workers are running');
+            }, 0);
+        };
+        if (document.readyState === 'complete') {
+            handleStartTracking();
+        }
+        else {
+            window.addEventListener('load', handleStartTracking);
+        }
+    }
+    initWorkers() {
+        this.initEventWorker();
+        this.initCallbackWorker();
+    }
+    initEventWorker() {
+        try {
+            // Create Event Worker from package source (bundled by the app/bundler)
+            this.eventWorker = new Worker(new URL('./event-worker.ts', import.meta.url), {
+                type: 'module',
+            });
+            this.eventWorker.onmessage = (e) => {
+                const { type, data } = e.data;
+                this.workerStatus.eventWorker = 'active';
+                switch (type) {
+                    case 'processed':
+                        this.sendToCallbackWorker({
+                            type: 'processedResult',
+                            event: data.event,
+                            eventType: data.event,
+                            processedData: data.processedData,
+                            timestamp: Date.now(),
+                        });
+                        break;
+                    case 'error':
+                        this.handleError(data);
+                        break;
+                    default:
+                }
+            };
+            this.eventWorker.onerror = (error) => {
+                this.workerStatus.eventWorker = 'error';
+                this.handleError({ message: 'Event Worker crashed', error });
+            };
+            // Send initial config to Event Worker
+            this.sendToEventWorker({ type: 'init', config: this.config });
+            this.workerStatus.eventWorker = 'ready';
+        }
+        catch (error) {
+            this.handleError({ message: 'Failed to create Event Worker', error });
+        }
+    }
+    initCallbackWorker() {
+        try {
+            this.callbackWorker = new Worker(new URL('./callback-worker.ts', import.meta.url), {
+                type: 'module',
+            });
+            this.callbackWorker.onmessage = (e) => {
+                const { type, data } = e.data;
+                this.workerStatus.callbackWorker = 'active';
+                switch (type) {
+                    case 'executeCallbacks': {
+                        // Execute registered callbacks on main thread and send result back
+                        const { eventType, requestId, payload } = e.data || {};
+                        const callbacks = (eventType && this.callbacks[eventType]) || [];
+                        let successCount = 0;
+                        let errorCount = 0;
+                        const start = Date.now();
+                        const perEventId = (payload && payload.data && payload.data.eventId);
+                        const perEventCb = perEventId ? this.perEventCallbacks.get(perEventId) : undefined;
+                        if (perEventCb) {
+                            try {
+                                perEventCb(payload);
+                                successCount++;
+                            }
+                            catch (err) {
+                                errorCount++;
+                            }
+                            finally {
+                                this.perEventCallbacks.delete(perEventId);
+                            }
+                        }
+                        if (callbacks.length > 0) {
+                            callbacks.forEach((cb) => {
+                                try {
+                                    cb(payload);
+                                    successCount++;
+                                }
+                                catch (err) {
+                                    errorCount++;
+                                    // also forward error to error handlers if any
+                                    if (this.callbacks.error) {
+                                        this.callbacks.error.forEach((eCb) => {
+                                            try {
+                                                eCb({
+                                                    type: 'error',
+                                                    data: {
+                                                        message: 'Callback error',
+                                                        error: this.serializeError(err),
+                                                    },
+                                                    timestamp: Date.now(),
+                                                    processingTime: 0,
+                                                    workerId: 'tracking-sdk',
+                                                });
+                                            }
+                                            catch (_a) { }
+                                        });
+                                    }
+                                }
+                            });
+                        }
+                        const executionTime = Date.now() - start;
+                        // Respond to worker with results
+                        this.sendToCallbackWorker({
+                            type: 'executionResult',
+                            requestId,
+                            successCount,
+                            errorCount,
+                            executionTime,
+                        });
+                        break;
+                    }
+                    case 'callbackReady':
+                        debugTrackers.log('📨 Callback processed successfully');
+                        break;
+                    case 'error':
+                        this.handleError(data);
+                        break;
+                    default:
+                }
+            };
+            this.callbackWorker.onerror = (error) => {
+                this.workerStatus.callbackWorker = 'error';
+                this.handleError({ message: 'Callback Worker crashed', error });
+            };
+            // Send initial config to Callback Worker
+            this.sendToCallbackWorker({
+                type: 'init',
+                config: this.config,
+                callbacks: Object.keys(this.callbacks), // Inform about registered callbacks
+            });
+            this.workerStatus.callbackWorker = 'ready';
+        }
+        catch (error) {
+            this.handleError({ message: 'Failed to create Callback Worker', error });
+        }
+    }
+    startTracking() {
+        if (typeof window === 'undefined')
+            return;
+        debugTrackers.log('👁️ Starting event tracking...', this.config.events);
+        // Track page load events
+        if (this.config.events.includes(ITrackingEvent.PAGE_LOAD)) {
+            this.handlePageLoad();
+        }
+        // Track user clicks
+        this.config.events.includes(ITrackingEvent.CLICK) && document.addEventListener('click', this.handleClick);
+        // Track performance metrics
+        if (this.config.events.includes(ITrackingEvent.PERFORMANCE) && 'PerformanceObserver' in window) {
+            const observer = new PerformanceObserver((list) => {
+                list.getEntries().forEach((entry) => {
+                    this.trackEvent(ITrackingEvent.PERFORMANCE_ENTRY, {
+                        name: entry.name,
+                        entryType: entry.entryType,
+                        duration: Math.round(entry.duration),
+                        startTime: Math.round(entry.startTime),
+                        timestamp: Date.now(),
+                    });
+                });
+            });
+            observer.observe({
+                entryTypes: ['navigation', 'paint', 'resource', 'largest-contentful-paint'],
+            });
+        }
+        debugTrackers.log('✅ All event listeners attached');
+    }
+    trackEvent(eventName, data, callback) {
+        if (!this.isInitialized) {
+            debugTrackers.warn('SDK not initialized. Call init() first.');
+            return;
+        }
+        const eventId = data.eventId || `ev_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        if (callback) {
+            this.perEventCallbacks.set(eventId, callback);
+        }
+        const eventData = {
+            type: 'track',
+            event: eventName,
+            data: Object.assign(Object.assign({}, data), { timestamp: Date.now(), eventId }),
+        };
+        debugTrackers.log('📤 Sending event to Event Worker:', eventName, eventData.data);
+        this.sendToEventWorker(eventData);
+    }
+    // Communication methods
+    sendToEventWorker(message) {
+        if (!this.eventWorker) {
+            debugTrackers.error('Event Worker not initialized');
+            return;
+        }
+        this.eventWorker.postMessage(message);
+    }
+    sendToCallbackWorker(message) {
+        if (!this.callbackWorker) {
+            debugTrackers.error('Callback Worker not initialized');
+            return;
+        }
+        this.callbackWorker.postMessage(message);
+    }
+    // Callback registration
+    on(eventType, callback) {
+        if (!this.callbacks[eventType]) {
+            this.callbacks[eventType] = [];
+        }
+        this.callbacks[eventType].push(callback);
+        debugTrackers.log(`🔗 Registered callback for "${eventType}". Total: ${this.callbacks[eventType].length}`);
+        // Notify Callback Worker about new callback
+        this.sendToCallbackWorker({
+            type: 'registerCallback',
+            eventType: eventType,
+            callbackCount: this.callbacks[eventType].length,
+        });
+        return () => {
+            // Return unsubscribe function
+            if (!this.callbacks[eventType])
+                return;
+            const index = this.callbacks[eventType].indexOf(callback);
+            if (index > -1) {
+                this.callbacks[eventType].splice(index, 1);
+                debugTrackers.log(`❌ Unregistered callback for "${eventType}"`);
+            }
+        };
+    }
+    // Error handling
+    handleError(errorData) {
+        const serialized = this.serializeError(errorData);
+        if (this.callbacks.error) {
+            this.callbacks.error.forEach((cb) => cb(serialized));
+        }
+        this.sendToCallbackWorker({
+            type: 'error',
+            data: serialized,
+            timestamp: Date.now(),
+        });
+    }
+    serializeError(input) {
+        try {
+            if (!input)
+                return { message: 'Unknown error' };
+            if (input instanceof Error) {
+                return { message: input.message, name: input.name, stack: input.stack };
+            }
+            if (typeof input === 'string')
+                return { message: input };
+            if (input.message || input.error) {
+                const err = input.error;
+                const base = {
+                    message: input.message || 'Error',
+                    context: undefined,
+                };
+                if (err instanceof Error) {
+                    return Object.assign(Object.assign({}, base), { error: { message: err.message, name: err.name, stack: err.stack } });
+                }
+                try {
+                    return Object.assign(Object.assign({}, base), { error: JSON.parse(JSON.stringify(err)) });
+                }
+                catch (_a) {
+                    return Object.assign(Object.assign({}, base), { error: String(err) });
+                }
+            }
+            return JSON.parse(JSON.stringify(input));
+        }
+        catch (_b) {
+            return { message: 'Unserializable error' };
+        }
+    }
+    // Health check
+    getStatus() {
+        return {
+            isInitialized: this.isInitialized,
+            workerStatus: this.workerStatus,
+            registeredCallbacks: Object.keys(this.callbacks),
+            totalCallbacks: Object.values(this.callbacks).reduce((sum, cbs) => sum + cbs.length, 0),
+        };
+    }
+    // Cleanup
+    destroy() {
+        debugTrackers.log('🧹 Destroying GXTrackingSDK...');
+        // Remove event listeners
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('load', this.handlePageLoad);
+            document.removeEventListener('click', this.handleClick);
+        }
+        // Terminate workers
+        if (this.eventWorker) {
+            this.eventWorker.terminate();
+            this.eventWorker = null;
+            debugTrackers.log('🔌 Event Worker terminated');
+        }
+        if (this.callbackWorker) {
+            this.callbackWorker.terminate();
+            this.callbackWorker = null;
+            debugTrackers.log('🔌 Callback Worker terminated');
+        }
+        // Clear callbacks
+        this.callbacks = {};
+        this.isInitialized = false;
+        this.workerStatus = {
+            eventWorker: 'destroyed',
+            callbackWorker: 'destroyed',
+        };
+        debugTrackers.log('✅ GXTrackingSDK destroyed successfully');
+    }
+}
+// Create and expose the SDK instance
+const gxTrackingSDK = new GXTrackingSDK();
+// Make it available globally
+if (typeof window !== 'undefined') {
+    window.GXTrackingSDK = gxTrackingSDK;
+}
+
+export { ITrackingEvent, gxTrackingSDK };

package/dist/esm/tooling/tsconfig/dist/callback-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tooling/tsconfig/dist/data/callbackStore.d.ts

@@ -0,0 +1,20 @@
+import type { ICallbackQueueItem, ICallbackStats, IPerformanceMetrics, IProcessedEventData, ITrackingConfig } from '../types';
+interface CallbackStore {
+    getRegisteredCallbacks(): Record<string, number>;
+    getCallbackQueue(): ICallbackQueueItem[];
+    getIsProcessingCallbacks(): boolean;
+    getCallbackStats(): ICallbackStats;
+    getPendingExecutions(): Record<string, (result: {
+        successCount: number;
+        errorCount: number;
+        executionTime: number;
+    }) => void>;
+    setConfig(newConfig: ITrackingConfig): void;
+    setRegisteredCallbacks(newRegisteredCallbacks: Record<string, number>): void;
+    executeCallbacksForEvent(queueItem: ICallbackQueueItem): Promise<void>;
+    processCallbackQueue(): Promise<void>;
+    handleProcessedEvent(eventType: string, processedData: IProcessedEventData, metrics?: IPerformanceMetrics): void;
+    handleErrorEvent(eventType: string, errorData: IProcessedEventData): void;
+}
+export declare const callbackStore: CallbackStore;
+export default callbackStore;

package/dist/esm/tooling/tsconfig/dist/data/eventStore.d.ts

@@ -0,0 +1,14 @@
+import type { IEventData, IProcessingQueueItem, ITrackingConfig } from '../types';
+interface EventStore {
+    getConfig(): ITrackingConfig;
+    getProcessingQueue(): IProcessingQueueItem[];
+    getIsProcessing(): boolean;
+    setConfig(newConfig: ITrackingConfig): void;
+    setProcessingQueue(newProcessingQueue: IProcessingQueueItem[]): void;
+    setIsProcessing(newIsProcessing: boolean): void;
+    processSingleEvent(eventName: string, eventData: IEventData): Promise<void>;
+    processQueue(): Promise<void>;
+    processEvent(eventName: string, eventData: IEventData): void;
+}
+export declare const eventStore: EventStore;
+export default eventStore;

package/dist/esm/tooling/tsconfig/dist/data/index.d.ts

@@ -0,0 +1,2 @@
+export * from './callbackStore';
+export * from './eventStore';

package/dist/esm/tooling/tsconfig/dist/debug/index.d.ts

@@ -0,0 +1,9 @@
+declare class DebugTrackers {
+    private enableLog;
+    constructor(enableLog?: boolean);
+    log(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare const debugTrackers: DebugTrackers;
+export {};

package/dist/esm/tooling/tsconfig/dist/event-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/click-handler.d.ts

@@ -0,0 +1,2 @@
+import type { IEventData, IProcessedClickData } from '../../types';
+export declare function processClick(data: IEventData): Promise<IProcessedClickData>;

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/index.d.ts

@@ -0,0 +1,5 @@
+export * from './click-handler';
+export * from './page-view-handler';
+export * from './performance-entry-handler';
+export * from './performance-handler';
+export * from './scroll-handler';

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/page-view-handler.d.ts

@@ -0,0 +1,2 @@
+import type { IEventData, IProcessedPageViewData } from '../../types';
+export declare function processPageView(data: IEventData): Promise<IProcessedPageViewData>;

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/performance-entry-handler.d.ts

@@ -0,0 +1,2 @@
+import type { IEventData, IProcessedPerformanceEntryData } from '../../types';
+export declare function processPerformanceEntry(data: IEventData): Promise<IProcessedPerformanceEntryData>;

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/performance-handler.d.ts

@@ -0,0 +1,2 @@
+import type { IEventData, IPerformanceMetrics } from '../../types';
+export declare function processPerformance(data: IEventData): Promise<IPerformanceMetrics>;

package/dist/esm/tooling/tsconfig/dist/handlers/event-worker/scroll-handler.d.ts

@@ -0,0 +1,2 @@
+import type { IEventData, IProcessedScrollData } from '../../types';
+export declare function processScroll(data: IEventData): Promise<IProcessedScrollData>;

package/dist/esm/tooling/tsconfig/dist/handlers/index.d.ts

@@ -0,0 +1 @@
+export * from './event-worker';

package/dist/esm/tooling/tsconfig/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './tracking-sdk';
+export * from './types';

package/dist/esm/tooling/tsconfig/dist/tracking-sdk.d.ts

@@ -0,0 +1,54 @@
+import type { EventCallback, IEventData, ITrackingConfig, ITrackingSDKStatus, IWorkerMessage, IWorkerStatus, UnsubscribeFunction } from './types';
+import { ITrackingEvent } from './types';
+declare global {
+    interface Window {
+        GXTrackingSDK: ITrackingSDKInterface;
+    }
+}
+export interface ITrackingSDKInterface {
+    config: ITrackingConfig;
+    isInitialized: boolean;
+    eventWorker: Worker | null;
+    callbackWorker: Worker | null;
+    callbacks: Record<string, EventCallback[]>;
+    workerStatus: IWorkerStatus;
+    init(userConfig?: Partial<ITrackingConfig>): void;
+    initWorkers(): void;
+    initEventWorker(): void;
+    initCallbackWorker(): void;
+    startTracking(): void;
+    trackEvent(eventName: ITrackingEvent, data: IEventData, callback?: EventCallback): void;
+    sendToEventWorker(message: IWorkerMessage): void;
+    sendToCallbackWorker(message: IWorkerMessage): void;
+    on(eventType: string, callback: EventCallback): UnsubscribeFunction;
+    handleError(errorData: any): void;
+    getStatus(): ITrackingSDKStatus;
+    destroy(): void;
+}
+declare class GXTrackingSDK implements ITrackingSDKInterface {
+    config: ITrackingConfig;
+    isInitialized: boolean;
+    eventWorker: Worker | null;
+    callbackWorker: Worker | null;
+    callbacks: Record<string, EventCallback[]>;
+    workerStatus: IWorkerStatus;
+    private perEventCallbacks;
+    constructor();
+    init(userConfig?: Partial<ITrackingConfig>): void;
+    initWorkers(): void;
+    initEventWorker(): void;
+    initCallbackWorker(): void;
+    startTracking(): void;
+    trackEvent(eventName: ITrackingEvent, data: IEventData, callback?: EventCallback): void;
+    sendToEventWorker(message: IWorkerMessage): void;
+    sendToCallbackWorker(message: IWorkerMessage): void;
+    on(eventType: string, callback: EventCallback): UnsubscribeFunction;
+    handleError(errorData: any): void;
+    private serializeError;
+    getStatus(): ITrackingSDKStatus;
+    destroy(): void;
+    private handlePageLoad;
+    private handleClick;
+}
+declare const gxTrackingSDK: GXTrackingSDK;
+export { gxTrackingSDK };

package/dist/esm/tooling/tsconfig/dist/types/callback.d.ts

@@ -0,0 +1,43 @@
+import type { IPerformanceMetrics, IProcessedEventData } from './event';
+import type { ITrackingConfig } from './tracking';
+import type { IWorkerMessage } from './worker';
+export interface ICallbackQueueItem {
+    eventType: string;
+    processedData: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    timestamp: number;
+    attempt: number;
+}
+export interface ICallbackStats {
+    totalProcessed: number;
+    totalErrors: number;
+    lastProcessed: number | null;
+}
+export interface ICallbackWorkerMessage extends IWorkerMessage {
+    type: 'init' | 'registerCallback' | 'processedResult' | 'error' | 'healthCheck' | 'executionResult';
+    eventType?: string;
+    processedData?: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    config?: ITrackingConfig;
+    callbackCount?: number;
+    requestId?: string;
+    successCount?: number;
+    errorCount?: number;
+    executionTime?: number;
+}
+export interface ICallbackWorkerResponse {
+    type: 'ready' | 'health' | 'callbackReady' | 'executionSummary' | 'callbackFailed' | 'heartbeat';
+    message?: string;
+    status?: 'busy' | 'idle';
+    queueLength?: number;
+    stats?: ICallbackStats;
+    eventType?: string;
+    successCount?: number;
+    errorCount?: number;
+    executionTime?: number;
+    dataSample?: IProcessedEventData;
+    error?: string;
+    finalAttempt?: boolean;
+    timestamp?: number;
+    processing?: boolean;
+}