@levi123/trackers 4.0.0-dev.0

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

@@ -0,0 +1,91 @@
+import type { ITrackingConfig } from './tracking';
+import type { IWorkerMessage } from './worker';
+export interface IEventData {
+    timestamp: number;
+    eventId?: string;
+    [key: string]: any;
+}
+export interface IProcessedEventData extends IEventData {
+    eventType: string;
+    processed: boolean;
+    [key: string]: any;
+}
+export interface IPerformanceMetrics {
+    manualTrigger?: boolean;
+    timestamp: number;
+    cpuUsage?: number;
+    memoryUsage?: number;
+    networkSpeed?: number;
+    processingTime: number;
+    entryCount?: number;
+    largestContentfulPaint?: number;
+}
+export interface ICallbackData {
+    type: string;
+    data: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    timestamp: number;
+    processingTime: number;
+    workerId: string;
+}
+export interface IProcessingQueueItem {
+    eventName: string;
+    eventData: IEventData;
+    timestamp: number;
+}
+export interface IEventWorkerMessage extends IWorkerMessage {
+    type: 'init' | 'track' | 'healthCheck';
+    event?: string;
+    data?: IEventData;
+    config?: ITrackingConfig;
+}
+export interface IEventWorkerResponse {
+    type: 'ready' | 'health' | 'processed' | 'error';
+    message?: string;
+    status?: 'busy' | 'idle';
+    queueLength?: number;
+    data?: {
+        event: string;
+        processedData?: IProcessedEventData;
+        metrics?: IPerformanceMetrics;
+        processingTime?: number;
+        workerTimestamp?: number;
+        error?: {
+            message: string;
+            stack?: string;
+            timestamp: number;
+        };
+    };
+}
+export interface INavigationTiming {
+    navigationStart: number;
+    domContentLoaded: number;
+    loadEvent: number;
+    totalLoadTime: number;
+}
+export interface IProcessedClickData extends IProcessedEventData {
+    eventType: ITrackingEvent.CLICK;
+    sessionId: string;
+}
+export interface IProcessedPageViewData extends IProcessedEventData {
+    eventType: ITrackingEvent.PAGE_LOAD;
+    userAgent: string;
+}
+export interface IProcessedScrollData extends IProcessedEventData {
+    eventType: ITrackingEvent.SCROLL;
+    scrollPercentage: number;
+}
+export interface IProcessedPerformanceEntryData extends IProcessedEventData {
+    eventType: ITrackingEvent.PERFORMANCE_ENTRY;
+    category: string;
+}
+export type EventCallback = (data: ICallbackData) => void;
+export type UnsubscribeFunction = () => void;
+export declare enum ITrackingEvent {
+    PAGE_LOAD = "pageLoad",
+    CLICK = "click",
+    PERFORMANCE = "performance",
+    PERFORMANCE_ENTRY = "performanceEntry",
+    SCROLL = "scroll",
+    MANUAL_CLICK = "manualClick"
+}

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

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

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

@@ -0,0 +1,16 @@
+import type { ITrackingEvent } from './event';
+import type { WorkerStatus } from './worker';
+export interface ITrackingConfig {
+    events: ITrackingEvent[];
+    workerTimeout?: number;
+}
+export interface IWorkerStatus {
+    eventWorker: WorkerStatus;
+    callbackWorker: WorkerStatus;
+}
+export interface ITrackingSDKStatus {
+    isInitialized: boolean;
+    workerStatus: IWorkerStatus;
+    registeredCallbacks: string[];
+    totalCallbacks: number;
+}

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

@@ -0,0 +1,21 @@
+import type { IPerformanceMetrics, IProcessedEventData } from './event';
+import type { ITrackingConfig } from './tracking';
+export interface IWorkerMessage {
+    type: string;
+    data?: any;
+    event?: string;
+    processedData?: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    config?: ITrackingConfig;
+    eventType?: string;
+    callbackCount?: number;
+    timestamp?: number;
+    error?: any;
+    callbacks?: string[];
+    requestId?: string;
+    payload?: any;
+    successCount?: number;
+    errorCount?: number;
+    executionTime?: number;
+}
+export type WorkerStatus = 'idle' | 'ready' | 'active' | 'error' | 'destroyed';

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

@@ -0,0 +1 @@
+export declare function generateSessionId(): string;

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

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

package/dist/umd/index.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).ReactFlow={})}(this,function(e){"use strict";var t="undefined"!=typeof document?document.currentScript:null;const r=new class{constructor(e){this.enableLog=!!e}log(e,...t){this.enableLog&&console.log(e,...t)}warn(e,...t){this.enableLog&&console.warn(e,...t)}error(e,...t){this.enableLog&&console.error(e,...t)}};var a;e.ITrackingEvent=void 0,(a=e.ITrackingEvent||(e.ITrackingEvent={})).PAGE_LOAD="pageLoad",a.CLICK="click",a.PERFORMANCE="performance",a.PERFORMANCE_ENTRY="performanceEntry",a.SCROLL="scroll",a.MANUAL_CLICK="manualClick";const n=new class{constructor(){this.config={events:[e.ITrackingEvent.PAGE_LOAD,e.ITrackingEvent.CLICK],workerTimeout:5e3},this.isInitialized=!1,this.eventWorker=null,this.callbackWorker=null,this.callbacks={},this.workerStatus={eventWorker:"idle",callbackWorker:"idle"},this.perEventCallbacks=new Map,this.handlePageLoad=()=>{this.trackEvent(e.ITrackingEvent.PAGE_LOAD,{timestamp:Date.now(),url:window.location.href})},this.handleClick=t=>{const r=t.target;"SCRIPT"!==r.tagName&&"STYLE"!==r.tagName||this.trackEvent(e.ITrackingEvent.CLICK,{target:r.tagName,targetId:r.id||"",targetClass:r.className||"",x:t.clientX,y:t.clientY,timestamp:Date.now()})},"undefined"==typeof window||window.Worker||r.warn("Web Worker not supported. Falling back to main thread.")}init(e={}){if(this.isInitialized)return void r.warn("SDK already initialized");Object.assign(this.config,e),r.log("🚀 GXTrackingSDK initialized with config:",this.config),this.initWorkers();const t=()=>{setTimeout(()=>{this.isInitialized=!0,this.startTracking(),r.log("✅ All workers are running")},0)};"complete"===document.readyState?t():window.addEventListener("load",t)}initWorkers(){this.initEventWorker(),this.initCallbackWorker()}initEventWorker(){try{this.eventWorker=new Worker(new URL("./event-worker.ts","undefined"==typeof document&&"undefined"==typeof location?require("url").pathToFileURL(__filename).href:"undefined"==typeof document?location.href:t&&"SCRIPT"===t.tagName.toUpperCase()&&t.src||new URL("index.js",document.baseURI).href),{type:"module"}),this.eventWorker.onmessage=e=>{const{type:t,data:r}=e.data;switch(this.workerStatus.eventWorker="active",t){case"processed":this.sendToCallbackWorker({type:"processedResult",event:r.event,eventType:r.event,processedData:r.processedData,timestamp:Date.now()});break;case"error":this.handleError(r)}},this.eventWorker.onerror=e=>{this.workerStatus.eventWorker="error",this.handleError({message:"Event Worker crashed",error:e})},this.sendToEventWorker({type:"init",config:this.config}),this.workerStatus.eventWorker="ready"}catch(e){this.handleError({message:"Failed to create Event Worker",error:e})}}initCallbackWorker(){try{this.callbackWorker=new Worker(new URL("./callback-worker.ts","undefined"==typeof document&&"undefined"==typeof location?require("url").pathToFileURL(__filename).href:"undefined"==typeof document?location.href:t&&"SCRIPT"===t.tagName.toUpperCase()&&t.src||new URL("index.js",document.baseURI).href),{type:"module"}),this.callbackWorker.onmessage=e=>{const{type:t,data:a}=e.data;switch(this.workerStatus.callbackWorker="active",t){case"executeCallbacks":{const{eventType:t,requestId:r,payload:a}=e.data||{},n=t&&this.callbacks[t]||[];let s=0,i=0;const o=Date.now(),c=a&&a.data&&a.data.eventId,l=c?this.perEventCallbacks.get(c):void 0;if(l)try{l(a),s++}catch(e){i++}finally{this.perEventCallbacks.delete(c)}n.length>0&&n.forEach(e=>{try{e(a),s++}catch(e){i++,this.callbacks.error&&this.callbacks.error.forEach(t=>{try{t({type:"error",data:{message:"Callback error",error:this.serializeError(e)},timestamp:Date.now(),processingTime:0,workerId:"tracking-sdk"})}catch(e){}})}});const k=Date.now()-o;this.sendToCallbackWorker({type:"executionResult",requestId:r,successCount:s,errorCount:i,executionTime:k});break}case"callbackReady":r.log("📨 Callback processed successfully");break;case"error":this.handleError(a)}},this.callbackWorker.onerror=e=>{this.workerStatus.callbackWorker="error",this.handleError({message:"Callback Worker crashed",error:e})},this.sendToCallbackWorker({type:"init",config:this.config,callbacks:Object.keys(this.callbacks)}),this.workerStatus.callbackWorker="ready"}catch(e){this.handleError({message:"Failed to create Callback Worker",error:e})}}startTracking(){if("undefined"!=typeof window){if(r.log("👁️ Starting event tracking...",this.config.events),this.config.events.includes(e.ITrackingEvent.PAGE_LOAD)&&this.handlePageLoad(),this.config.events.includes(e.ITrackingEvent.CLICK)&&document.addEventListener("click",this.handleClick),this.config.events.includes(e.ITrackingEvent.PERFORMANCE)&&"PerformanceObserver"in window){new PerformanceObserver(t=>{t.getEntries().forEach(t=>{this.trackEvent(e.ITrackingEvent.PERFORMANCE_ENTRY,{name:t.name,entryType:t.entryType,duration:Math.round(t.duration),startTime:Math.round(t.startTime),timestamp:Date.now()})})}).observe({entryTypes:["navigation","paint","resource","largest-contentful-paint"]})}r.log("✅ All event listeners attached")}}trackEvent(e,t,a){if(!this.isInitialized)return void r.warn("SDK not initialized. Call init() first.");const n=t.eventId||`ev_${Date.now()}_${Math.random().toString(36).slice(2)}`;a&&this.perEventCallbacks.set(n,a);const s={type:"track",event:e,data:Object.assign(Object.assign({},t),{timestamp:Date.now(),eventId:n})};r.log("📤 Sending event to Event Worker:",e,s.data),this.sendToEventWorker(s)}sendToEventWorker(e){this.eventWorker?this.eventWorker.postMessage(e):r.error("Event Worker not initialized")}sendToCallbackWorker(e){this.callbackWorker?this.callbackWorker.postMessage(e):r.error("Callback Worker not initialized")}on(e,t){return this.callbacks[e]||(this.callbacks[e]=[]),this.callbacks[e].push(t),r.log(`🔗 Registered callback for "${e}". Total: ${this.callbacks[e].length}`),this.sendToCallbackWorker({type:"registerCallback",eventType:e,callbackCount:this.callbacks[e].length}),()=>{if(!this.callbacks[e])return;const a=this.callbacks[e].indexOf(t);a>-1&&(this.callbacks[e].splice(a,1),r.log(`❌ Unregistered callback for "${e}"`))}}handleError(e){const t=this.serializeError(e);this.callbacks.error&&this.callbacks.error.forEach(e=>e(t)),this.sendToCallbackWorker({type:"error",data:t,timestamp:Date.now()})}serializeError(e){try{if(!e)return{message:"Unknown error"};if(e instanceof Error)return{message:e.message,name:e.name,stack:e.stack};if("string"==typeof e)return{message:e};if(e.message||e.error){const t=e.error,r={message:e.message||"Error",context:void 0};if(t instanceof Error)return Object.assign(Object.assign({},r),{error:{message:t.message,name:t.name,stack:t.stack}});try{return Object.assign(Object.assign({},r),{error:JSON.parse(JSON.stringify(t))})}catch(e){return Object.assign(Object.assign({},r),{error:String(t)})}}return JSON.parse(JSON.stringify(e))}catch(e){return{message:"Unserializable error"}}}getStatus(){return{isInitialized:this.isInitialized,workerStatus:this.workerStatus,registeredCallbacks:Object.keys(this.callbacks),totalCallbacks:Object.values(this.callbacks).reduce((e,t)=>e+t.length,0)}}destroy(){r.log("🧹 Destroying GXTrackingSDK..."),"undefined"!=typeof window&&(window.removeEventListener("load",this.handlePageLoad),document.removeEventListener("click",this.handleClick)),this.eventWorker&&(this.eventWorker.terminate(),this.eventWorker=null,r.log("🔌 Event Worker terminated")),this.callbackWorker&&(this.callbackWorker.terminate(),this.callbackWorker=null,r.log("🔌 Callback Worker terminated")),this.callbacks={},this.isInitialized=!1,this.workerStatus={eventWorker:"destroyed",callbackWorker:"destroyed"},r.log("✅ GXTrackingSDK destroyed successfully")}};"undefined"!=typeof window&&(window.GXTrackingSDK=n),e.gxTrackingSDK=n});

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

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

package/dist/umd/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/umd/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/umd/tooling/tsconfig/dist/data/index.d.ts

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

package/dist/umd/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/umd/tooling/tsconfig/dist/event-worker.d.ts

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

package/dist/umd/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/umd/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/umd/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/umd/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/umd/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/umd/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/umd/tooling/tsconfig/dist/handlers/index.d.ts

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

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

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

package/dist/umd/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/umd/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;
+}

package/dist/umd/tooling/tsconfig/dist/types/event.d.ts

@@ -0,0 +1,91 @@
+import type { ITrackingConfig } from './tracking';
+import type { IWorkerMessage } from './worker';
+export interface IEventData {
+    timestamp: number;
+    eventId?: string;
+    [key: string]: any;
+}
+export interface IProcessedEventData extends IEventData {
+    eventType: string;
+    processed: boolean;
+    [key: string]: any;
+}
+export interface IPerformanceMetrics {
+    manualTrigger?: boolean;
+    timestamp: number;
+    cpuUsage?: number;
+    memoryUsage?: number;
+    networkSpeed?: number;
+    processingTime: number;
+    entryCount?: number;
+    largestContentfulPaint?: number;
+}
+export interface ICallbackData {
+    type: string;
+    data: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    timestamp: number;
+    processingTime: number;
+    workerId: string;
+}
+export interface IProcessingQueueItem {
+    eventName: string;
+    eventData: IEventData;
+    timestamp: number;
+}
+export interface IEventWorkerMessage extends IWorkerMessage {
+    type: 'init' | 'track' | 'healthCheck';
+    event?: string;
+    data?: IEventData;
+    config?: ITrackingConfig;
+}
+export interface IEventWorkerResponse {
+    type: 'ready' | 'health' | 'processed' | 'error';
+    message?: string;
+    status?: 'busy' | 'idle';
+    queueLength?: number;
+    data?: {
+        event: string;
+        processedData?: IProcessedEventData;
+        metrics?: IPerformanceMetrics;
+        processingTime?: number;
+        workerTimestamp?: number;
+        error?: {
+            message: string;
+            stack?: string;
+            timestamp: number;
+        };
+    };
+}
+export interface INavigationTiming {
+    navigationStart: number;
+    domContentLoaded: number;
+    loadEvent: number;
+    totalLoadTime: number;
+}
+export interface IProcessedClickData extends IProcessedEventData {
+    eventType: ITrackingEvent.CLICK;
+    sessionId: string;
+}
+export interface IProcessedPageViewData extends IProcessedEventData {
+    eventType: ITrackingEvent.PAGE_LOAD;
+    userAgent: string;
+}
+export interface IProcessedScrollData extends IProcessedEventData {
+    eventType: ITrackingEvent.SCROLL;
+    scrollPercentage: number;
+}
+export interface IProcessedPerformanceEntryData extends IProcessedEventData {
+    eventType: ITrackingEvent.PERFORMANCE_ENTRY;
+    category: string;
+}
+export type EventCallback = (data: ICallbackData) => void;
+export type UnsubscribeFunction = () => void;
+export declare enum ITrackingEvent {
+    PAGE_LOAD = "pageLoad",
+    CLICK = "click",
+    PERFORMANCE = "performance",
+    PERFORMANCE_ENTRY = "performanceEntry",
+    SCROLL = "scroll",
+    MANUAL_CLICK = "manualClick"
+}

package/dist/umd/tooling/tsconfig/dist/types/index.d.ts

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

package/dist/umd/tooling/tsconfig/dist/types/tracking.d.ts

@@ -0,0 +1,16 @@
+import type { ITrackingEvent } from './event';
+import type { WorkerStatus } from './worker';
+export interface ITrackingConfig {
+    events: ITrackingEvent[];
+    workerTimeout?: number;
+}
+export interface IWorkerStatus {
+    eventWorker: WorkerStatus;
+    callbackWorker: WorkerStatus;
+}
+export interface ITrackingSDKStatus {
+    isInitialized: boolean;
+    workerStatus: IWorkerStatus;
+    registeredCallbacks: string[];
+    totalCallbacks: number;
+}

package/dist/umd/tooling/tsconfig/dist/types/worker.d.ts

@@ -0,0 +1,21 @@
+import type { IPerformanceMetrics, IProcessedEventData } from './event';
+import type { ITrackingConfig } from './tracking';
+export interface IWorkerMessage {
+    type: string;
+    data?: any;
+    event?: string;
+    processedData?: IProcessedEventData;
+    metrics?: IPerformanceMetrics;
+    config?: ITrackingConfig;
+    eventType?: string;
+    callbackCount?: number;
+    timestamp?: number;
+    error?: any;
+    callbacks?: string[];
+    requestId?: string;
+    payload?: any;
+    successCount?: number;
+    errorCount?: number;
+    executionTime?: number;
+}
+export type WorkerStatus = 'idle' | 'ready' | 'active' | 'error' | 'destroyed';

package/dist/umd/tooling/tsconfig/dist/utils/event-worker.d.ts

@@ -0,0 +1 @@
+export declare function generateSessionId(): string;

package/dist/umd/tooling/tsconfig/dist/utils/index.d.ts

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

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@levi123/trackers",
+  "version": "4.0.0-dev.0",
+  "license": "MIT",
+  "type": "module",
+  "source": "src/index.ts",
+  "scripts": {
+    "build": "rollup --config node:@levi123/rollup-config --environment NODE_ENV:production",
+    "clean": "rm -rf dist",
+    "dev": "echo 'Add dev script here'",
+    "format": "prettier --write \"**/*.{ts,tsx,md}\"",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:all": "yarn lint && yarn lint:tsc",
+    "lint:tsc": "tsc --noEmit",
+    "post:publish": "node ../../scripts/convert-publish.js",
+    "pre:publish": "node ../../scripts/convert-publish.js -p",
+    "test": "jest --runInBand"
+  },
+  "devDependencies": {
+    "eslint": "9.36.0",
+    "rollup": "3.29.5"
+  },
+  "main": "dist/umd/index.js",
+  "files": [
+    "dist"
+  ],
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "node": {
+        "types": "./dist/esm/index.d.ts",
+        "module": "./dist/esm/index.js",
+        "require": "./dist/umd/index.js",
+        "import": "./dist/esm/index.mjs"
+      },
+      "browser": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/umd/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    }
+  }
+}