getu-attribution-v2-sdk 0.1.0

package/dist/index.esm.js

@@ -0,0 +1,1859 @@
+// Event types matching server-side enum exactly
+var EventType;
+(function (EventType) {
+    // Pre-conversion signals
+    EventType["PAGE_VIEW"] = "page_view";
+    EventType["VIDEO_PLAY"] = "video_play";
+    // Registration funnel
+    EventType["FORM_SUBMIT"] = "form_submit";
+    EventType["EMAIL_VERIFICATION"] = "email_verification";
+    // Login flow
+    EventType["LOGIN"] = "login";
+    // Signup flow
+    EventType["SIGNUP"] = "signup";
+    // Purchase funnel
+    EventType["PRODUCT_VIEW"] = "product_view";
+    EventType["ADD_TO_CART"] = "add_to_cart";
+    EventType["PURCHASE"] = "purchase";
+})(EventType || (EventType = {}));
+// Currency types
+var Currency;
+(function (Currency) {
+    Currency["USD"] = "USD";
+})(Currency || (Currency = {}));
+const defaultEndpoint = "https://attribution.getu.ai/attribution/api";
+// Special events that should be sent immediately
+const IMMEDIATE_EVENTS = [
+    EventType.PURCHASE,
+    EventType.LOGIN,
+    EventType.SIGNUP,
+    EventType.FORM_SUBMIT,
+    EventType.EMAIL_VERIFICATION,
+];
+
+// Generate unique ID
+function generateId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+// Generate timestamp in seconds
+function getTimestamp() {
+    return Math.floor(Date.now() / 1000);
+}
+// Parse URL parameters
+function parseUrlParams(url) {
+    const params = {};
+    try {
+        const urlObj = new URL(url);
+        urlObj.searchParams.forEach((value, key) => {
+            params[key] = value;
+        });
+    }
+    catch (error) {
+        // Handle invalid URLs
+    }
+    return params;
+}
+// Extract UTM parameters from URL
+function extractUTMParams(url) {
+    const params = parseUrlParams(url);
+    const utmParams = {};
+    const utmKeys = [
+        "utm_source",
+        "utm_medium",
+        "utm_campaign",
+        "utm_term",
+        "utm_content",
+    ];
+    utmKeys.forEach((key) => {
+        if (params[key] && params[key].trim() !== "") {
+            utmParams[key] = params[key].trim();
+        }
+    });
+    return utmParams;
+}
+// Check if browser supports localStorage
+function isLocalStorageSupported() {
+    try {
+        const test = "__localStorage_test__";
+        localStorage.setItem(test, test);
+        localStorage.removeItem(test);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Check if browser supports IndexedDB
+function isIndexedDBSupported() {
+    return "indexedDB" in window;
+}
+// Debounce function
+function debounce(func, wait) {
+    let timeout;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func(...args), wait);
+    };
+}
+// Retry function with exponential backoff
+async function retry(fn, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (i === maxRetries) {
+                throw lastError;
+            }
+            const delay = baseDelay * Math.pow(2, i);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+// Console logger implementation
+class ConsoleLogger {
+    constructor(enabled = true) {
+        this.enabled = enabled;
+    }
+    debug(message, ...args) {
+        if (this.enabled && console.debug) {
+            console.debug(`[GetuAI Debug] ${message}`, ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.enabled && console.info) {
+            console.info(`[GetuAI Info] ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.enabled && console.warn) {
+            console.warn(`[GetuAI Warn] ${message}`, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.enabled && console.error) {
+            console.error(`[GetuAI Error] ${message}`, ...args);
+        }
+    }
+}
+// Get user agent info
+function getUserAgent() {
+    return navigator.userAgent || "";
+}
+// Get referrer
+function getReferrer() {
+    return document.referrer || "";
+}
+// Get current URL
+function getCurrentUrl() {
+    return window.location.href;
+}
+// Get page title
+function getPageTitle() {
+    return document.title || "";
+}
+// Check if user is online
+function isOnline() {
+    return navigator.onLine;
+}
+// Generate session ID
+function generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+// Add UTM parameters to URL
+function addUTMToURL$1(url, utmParams) {
+    try {
+        const urlObj = new URL(url);
+        // Add UTM parameters if they don't already exist
+        Object.entries(utmParams).forEach(([key, value]) => {
+            if (value && !urlObj.searchParams.has(key)) {
+                urlObj.searchParams.set(key, value);
+            }
+        });
+        return urlObj.toString();
+    }
+    catch (error) {
+        // If URL parsing fails, return original URL
+        return url;
+    }
+}
+// Check if domain should be excluded from UTM passing
+function shouldExcludeDomain(url, excludeDomains = []) {
+    try {
+        const urlObj = new URL(url);
+        const hostname = urlObj.hostname.toLowerCase();
+        return excludeDomains.some((domain) => {
+            const excludeDomain = domain.toLowerCase();
+            return (hostname === excludeDomain || hostname.endsWith(`.${excludeDomain}`));
+        });
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Check if URL is external (different domain)
+function isExternalURL(url) {
+    try {
+        const urlObj = new URL(url);
+        const currentDomain = window.location.hostname;
+        return urlObj.hostname !== currentDomain;
+    }
+    catch (error) {
+        return false;
+    }
+}
+// Filter UTM parameters based on configuration
+function filterUTMParams(utmData, allowedParams = ["utm_source", "utm_medium", "utm_campaign"]) {
+    const filtered = {};
+    allowedParams.forEach((param) => {
+        if (utmData[param]) {
+            filtered[param] = utmData[param];
+        }
+    });
+    return filtered;
+}
+// Get query string from URL
+function getQueryString(url) {
+    try {
+        const targetUrl = url || window.location.href;
+        const urlObj = new URL(targetUrl);
+        return urlObj.search;
+    }
+    catch (error) {
+        return "";
+    }
+}
+// Get query parameters as object
+function getQueryParams(url) {
+    try {
+        const targetUrl = url || window.location.href;
+        const urlObj = new URL(targetUrl);
+        const params = {};
+        urlObj.searchParams.forEach((value, key) => {
+            params[key] = value;
+        });
+        return params;
+    }
+    catch (error) {
+        return {};
+    }
+}
+// Clean URL by removing UTM parameters
+function cleanURL() {
+    try {
+        const currentUrl = new URL(window.location.href);
+        const utmKeys = [
+            "utm_source",
+            "utm_medium",
+            "utm_campaign",
+            "utm_term",
+            "utm_content",
+        ];
+        let hasParams = false;
+        utmKeys.forEach((key) => {
+            if (currentUrl.searchParams.has(key)) {
+                currentUrl.searchParams.delete(key);
+                hasParams = true;
+            }
+        });
+        if (hasParams) {
+            // Use replaceState to avoid page reload and history entry
+            window.history.replaceState({}, document.title, currentUrl.toString());
+        }
+    }
+    catch (error) {
+        // Handle invalid URLs silently
+        console.warn("Failed to clean URL:", error);
+    }
+}
+
+// LocalStorage implementation
+class LocalStorageManager {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    get(key) {
+        try {
+            if (!isLocalStorageSupported()) {
+                this.logger.warn("LocalStorage not supported");
+                return null;
+            }
+            const item = localStorage.getItem(key);
+            if (item === null) {
+                return null;
+            }
+            return JSON.parse(item);
+        }
+        catch (error) {
+            this.logger.error("Error reading from localStorage:", error);
+            return null;
+        }
+    }
+    set(key, value) {
+        try {
+            if (!isLocalStorageSupported()) {
+                this.logger.warn("LocalStorage not supported");
+                return;
+            }
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (error) {
+            this.logger.error("Error writing to localStorage:", error);
+            // Handle quota exceeded
+            this.handleQuotaExceeded();
+        }
+    }
+    remove(key) {
+        try {
+            if (isLocalStorageSupported()) {
+                localStorage.removeItem(key);
+            }
+        }
+        catch (error) {
+            this.logger.error("Error removing from localStorage:", error);
+        }
+    }
+    clear() {
+        try {
+            if (isLocalStorageSupported()) {
+                localStorage.clear();
+            }
+        }
+        catch (error) {
+            this.logger.error("Error clearing localStorage:", error);
+        }
+    }
+    handleQuotaExceeded() {
+        // Try to clean up old data
+        try {
+            const keys = Object.keys(localStorage);
+            const attributionKeys = keys.filter((key) => key.startsWith("attribution_"));
+            if (attributionKeys.length > 0) {
+                // Remove oldest data first
+                attributionKeys.sort((a, b) => {
+                    const aData = this.get(a);
+                    const bData = this.get(b);
+                    return (aData?.expiresAt || 0) - (bData?.expiresAt || 0);
+                });
+                // Remove oldest 20% of data
+                const toRemove = Math.ceil(attributionKeys.length * 0.2);
+                attributionKeys.slice(0, toRemove).forEach((key) => {
+                    this.remove(key);
+                });
+                this.logger.info(`Cleaned up ${toRemove} old attribution records`);
+            }
+        }
+        catch (error) {
+            this.logger.error("Error during quota cleanup:", error);
+        }
+    }
+}
+// IndexedDB implementation
+class IndexedDBManager {
+    constructor(logger) {
+        this.dbName = "attribution_events";
+        this.dbVersion = 1;
+        this.storeName = "events";
+        this.db = null;
+        this.logger = logger;
+    }
+    async init() {
+        if (!isIndexedDBSupported()) {
+            this.logger.warn("IndexedDB not supported");
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onerror = () => {
+                this.logger.error("Failed to open IndexedDB:", request.error);
+                reject(request.error);
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                this.logger.info("IndexedDB initialized successfully");
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    const store = db.createObjectStore(this.storeName, {
+                        keyPath: "id",
+                        autoIncrement: true,
+                    });
+                    store.createIndex("timestamp", "timestamp", { unique: false });
+                    store.createIndex("sent", "sent", { unique: false });
+                    store.createIndex("queued_at", "queued_at", { unique: false });
+                }
+            };
+        });
+    }
+    async addEvent(event) {
+        if (!this.db) {
+            throw new Error("IndexedDB not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const eventRecord = {
+                ...event,
+                queued_at: Date.now(),
+                sent: false,
+            };
+            const request = store.add(eventRecord);
+            request.onsuccess = () => {
+                this.logger.debug("Event added to IndexedDB queue");
+                resolve();
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to add event to IndexedDB:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async getUnsentEvents(limit = 100) {
+        if (!this.db) {
+            return [];
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index("sent");
+            const request = index.getAll(IDBKeyRange.only(false), limit);
+            request.onsuccess = () => {
+                const events = request.result.map((record) => {
+                    const { queued_at, sent, ...event } = record;
+                    return event;
+                });
+                resolve(events);
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to get unsent events:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async markEventsAsSent(eventIds) {
+        if (!this.db || eventIds.length === 0) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            let completed = 0;
+            let hasError = false;
+            eventIds.forEach((eventId) => {
+                const getRequest = store.get(eventId);
+                getRequest.onsuccess = () => {
+                    if (getRequest.result) {
+                        const record = { ...getRequest.result, sent: true };
+                        const putRequest = store.put(record);
+                        putRequest.onsuccess = () => {
+                            completed++;
+                            if (completed === eventIds.length && !hasError) {
+                                resolve();
+                            }
+                        };
+                        putRequest.onerror = () => {
+                            hasError = true;
+                            this.logger.error("Failed to mark event as sent:", putRequest.error);
+                            reject(putRequest.error);
+                        };
+                    }
+                    else {
+                        completed++;
+                        if (completed === eventIds.length && !hasError) {
+                            resolve();
+                        }
+                    }
+                };
+                getRequest.onerror = () => {
+                    hasError = true;
+                    this.logger.error("Failed to get event for marking as sent:", getRequest.error);
+                    reject(getRequest.error);
+                };
+            });
+        });
+    }
+    async cleanupOldEvents(maxAge = 7 * 24 * 60 * 60 * 1000) {
+        if (!this.db) {
+            return;
+        }
+        const cutoffTime = Date.now() - maxAge;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index("queued_at");
+            const request = index.openCursor(IDBKeyRange.upperBound(cutoffTime));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    cursor.delete();
+                    cursor.continue();
+                }
+                else {
+                    this.logger.info("Old events cleanup completed");
+                    resolve();
+                }
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to cleanup old events:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async getQueueSize() {
+        if (!this.db) {
+            return 0;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.count();
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to get queue size:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async clear() {
+        if (!this.db) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onsuccess = () => {
+                this.logger.info("IndexedDB queue cleared");
+                resolve();
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to clear IndexedDB queue:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+}
+// Attribution storage manager
+class AttributionStorageManager {
+    constructor(logger) {
+        this.UTM_STORAGE_KEY = "attribution_utm_data";
+        this.SESSION_STORAGE_KEY = "attribution_session";
+        this.logger = logger;
+        this.localStorage = new LocalStorageManager(logger);
+        this.indexedDB = new IndexedDBManager(logger);
+    }
+    async init() {
+        await this.indexedDB.init();
+    }
+    // UTM data management
+    storeUTMData(utmData) {
+        try {
+            const existingData = this.getUTMData();
+            // Create default UTM data if none exists
+            const defaultUTMData = {
+                utm_source: "",
+                utm_medium: "",
+                utm_campaign: "",
+                utm_term: "",
+                utm_content: "",
+                timestamp: Date.now(),
+            };
+            const newData = {
+                firstTouch: existingData?.firstTouch || defaultUTMData,
+                lastTouch: existingData?.lastTouch || defaultUTMData,
+                touchpoints: existingData?.touchpoints || [],
+                ...utmData,
+                expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
+            };
+            this.localStorage.set(this.UTM_STORAGE_KEY, newData);
+            this.logger.debug("UTM data stored successfully:", {
+                firstTouch: newData.firstTouch,
+                lastTouch: newData.lastTouch,
+                touchpointsCount: newData.touchpoints.length,
+                expiresAt: new Date(newData.expiresAt).toISOString(),
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to store UTM data:", error);
+        }
+    }
+    getUTMData() {
+        const data = this.localStorage.get(this.UTM_STORAGE_KEY);
+        if (data && data.expiresAt && data.expiresAt > Date.now()) {
+            return data;
+        }
+        // Clean up expired data
+        if (data) {
+            this.localStorage.remove(this.UTM_STORAGE_KEY);
+        }
+        return null;
+    }
+    // Session management
+    storeSession(session) {
+        this.localStorage.set(this.SESSION_STORAGE_KEY, session);
+    }
+    getSession() {
+        return this.localStorage.get(this.SESSION_STORAGE_KEY);
+    }
+    // Event queue management
+    async queueEvent(event) {
+        try {
+            await this.indexedDB.addEvent(event);
+        }
+        catch (error) {
+            this.logger.error("Failed to queue event:", error);
+            throw error;
+        }
+    }
+    async getUnsentEvents(limit = 100) {
+        return await this.indexedDB.getUnsentEvents(limit);
+    }
+    async markEventsAsSent(eventIds) {
+        await this.indexedDB.markEventsAsSent(eventIds);
+    }
+    async getQueueSize() {
+        return await this.indexedDB.getQueueSize();
+    }
+    async cleanupOldEvents() {
+        await this.indexedDB.cleanupOldEvents();
+    }
+    async clearQueue() {
+        await this.indexedDB.clear();
+    }
+    // Cleanup expired data
+    cleanupExpiredData() {
+        this.getUTMData(); // This will automatically clean up expired UTM data
+    }
+}
+
+class EventQueueManager {
+    constructor(logger, apiKey, apiEndpoint, batchSize = 100, batchInterval = 5000, maxRetries = 3, retryDelay = 1000, sendEvents) {
+        this.queue = [];
+        this.processing = false;
+        this.batchTimer = null;
+        this.logger = logger;
+        this.apiKey = apiKey;
+        this.apiEndpoint = apiEndpoint;
+        this.batchSize = batchSize;
+        this.batchInterval = batchInterval;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+        this.sendEvents = sendEvents;
+        // Debounced process function to avoid excessive calls
+        this.debouncedProcess = debounce(this.process.bind(this), 100);
+    }
+    add(event) {
+        this.queue.push(event);
+        this.logger.debug(`Event added to queue: ${event.event_type}`);
+        // Check if this is an immediate event
+        if (IMMEDIATE_EVENTS.includes(event.event_type)) {
+            this.logger.debug(`Immediate event detected: ${event.event_type}, processing immediately`);
+            this.processImmediate(event);
+        }
+        else {
+            // Schedule batch processing
+            this.scheduleBatchProcessing();
+        }
+    }
+    async process() {
+        if (this.processing || this.queue.length === 0) {
+            return;
+        }
+        this.processing = true;
+        try {
+            const eventsToProcess = this.queue.splice(0, this.batchSize);
+            this.logger.debug(`Processing ${eventsToProcess.length} events from queue`);
+            const result = await this.sendEvents(eventsToProcess);
+            this.logger.info(`Successfully processed ${eventsToProcess.length} events`);
+            // Events are automatically removed from queue when successfully sent
+            // No need to manually clean up as they were already spliced from the queue
+        }
+        catch (error) {
+            this.logger.error("Failed to process events:", error);
+            // Put events back in queue for retry
+            const failedEvents = this.queue.splice(0, this.batchSize);
+            this.queue.unshift(...failedEvents);
+            // Schedule retry
+            setTimeout(() => {
+                this.processing = false;
+                this.debouncedProcess();
+            }, this.retryDelay);
+            return;
+        }
+        this.processing = false;
+        // Process remaining events if any
+        if (this.queue.length > 0) {
+            this.debouncedProcess();
+        }
+    }
+    async processImmediate(event) {
+        try {
+            this.logger.debug(`Processing immediate event: ${event.event_type}`);
+            await this.sendEvents([event]);
+            this.logger.info(`Immediate event processed successfully: ${event.event_type}`);
+            // Event is automatically removed from queue when successfully sent
+        }
+        catch (error) {
+            this.logger.error(`Failed to process immediate event: ${event.event_type}`, error);
+            // Add to queue for retry
+            this.queue.unshift(event);
+        }
+    }
+    scheduleBatchProcessing() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        this.batchTimer = setTimeout(() => {
+            this.debouncedProcess();
+        }, this.batchInterval);
+    }
+    clear() {
+        this.queue = [];
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        this.processing = false;
+        this.logger.info("Event queue cleared");
+    }
+    size() {
+        return this.queue.length;
+    }
+    // Get queue statistics
+    getStats() {
+        return {
+            size: this.queue.length,
+            processing: this.processing,
+        };
+    }
+    // Force process all events in queue
+    async flush() {
+        this.logger.info("Flushing event queue");
+        while (this.queue.length > 0) {
+            await this.process();
+        }
+    }
+}
+// HTTP client for sending events
+class EventHttpClient {
+    constructor(logger, apiKey, apiEndpoint, maxRetries = 3, retryDelay = 1000) {
+        this.logger = logger;
+        this.apiKey = apiKey;
+        this.apiEndpoint = apiEndpoint;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+    }
+    async sendEvents(events) {
+        if (events.length === 0) {
+            return;
+        }
+        // Transform events to match server format
+        const transformedEvents = events.map((event) => ({
+            event_id: event.event_id,
+            event_type: event.event_type,
+            tracking_user_id: event.tracking_user_id,
+            utm_source: event.utm_source || null,
+            utm_medium: event.utm_medium || null,
+            utm_campaign: event.utm_campaign || null,
+            utm_term: event.utm_term || null,
+            utm_content: event.utm_content || null,
+            revenue: event.revenue || null,
+            currency: event.currency || null,
+            event_data: event.event_data || null,
+            context: event.context || null,
+            timestamp: event.timestamp || getTimestamp(), // Convert to seconds
+        }));
+        const batchRequest = { events: transformedEvents };
+        await retry(async () => {
+            const response = await fetch(`${this.apiEndpoint}/attribution/events`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(batchRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            const result = await response.json();
+            this.logger.debug("Events sent successfully:", result);
+            // Return the sent events for cleanup
+            return { result, sentEvents: events };
+        }, this.maxRetries, this.retryDelay);
+    }
+    async sendSingleEvent(event) {
+        await this.sendEvents([event]);
+    }
+    // Test connection
+    async testConnection() {
+        try {
+            const response = await fetch(`${this.apiEndpoint}/health`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            return response.ok;
+        }
+        catch (error) {
+            this.logger.error("Connection test failed:", error);
+            return false;
+        }
+    }
+}
+
+class AttributionSDK {
+    constructor(config) {
+        this.session = null;
+        this.initialized = false;
+        this.autoTrackEnabled = false;
+        this.pageViewTrackTimes = new Map();
+        // SPA tracking internals
+        this.spaTrackingEnabled = false;
+        this.lastTrackedPath = "";
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+        this.popstateHandler = null;
+        this.config = {
+            apiEndpoint: defaultEndpoint,
+            batchSize: 100,
+            batchInterval: 5000,
+            maxRetries: 3,
+            retryDelay: 1000,
+            enableDebug: false,
+            autoTrack: false,
+            autoTrackPageView: false,
+            sessionTimeout: 30 * 60 * 1000, // 30 minutes
+            enableCrossDomainUTM: true,
+            crossDomainUTMParams: [
+                "utm_source",
+                "utm_medium",
+                "utm_campaign",
+                "utm_term",
+                "utm_content",
+            ],
+            excludeDomains: [],
+            autoCleanUTM: true,
+            pageViewDebounceInterval: 5000, // 5 seconds default
+            ...config,
+        };
+        this.logger = new ConsoleLogger(this.config.enableDebug);
+        this.storage = new AttributionStorageManager(this.logger);
+        this.httpClient = new EventHttpClient(this.logger, this.config.apiKey, this.config.apiEndpoint || defaultEndpoint, this.config.maxRetries, this.config.retryDelay);
+        this.queue = new EventQueueManager(this.logger, this.config.apiKey, this.config.apiEndpoint || defaultEndpoint, this.config.batchSize, this.config.batchInterval, this.config.maxRetries, this.config.retryDelay, (events) => this.httpClient.sendEvents(events));
+    }
+    async init() {
+        if (this.initialized) {
+            this.logger.warn("SDK already initialized");
+            return;
+        }
+        try {
+            this.logger.info("Initializing GetuAI Attribution SDK");
+            // Initialize storage
+            await this.storage.init();
+            // Initialize session
+            this.initializeSession();
+            // Extract and store UTM data from current URL
+            this.extractAndStoreUTMData();
+            // Setup auto-tracking if enabled
+            if (this.config.autoTrack) {
+                this.setupAutoTracking();
+            }
+            // Setup online/offline handlers
+            this.setupNetworkHandlers();
+            // Setup page visibility handlers
+            this.setupVisibilityHandlers();
+            // Setup beforeunload handler
+            this.setupBeforeUnloadHandler();
+            this.initialized = true;
+            this.logger.info("🚀 GetuAI Attribution SDK initialized successfully");
+            this.logger.info("📄 Auto track page view = " + this.config.autoTrackPageView);
+            // Auto track page view if enabled (independent from autoTrack)
+            // Also enables SPA route tracking automatically
+            if (this.config.autoTrackPageView) {
+                this.logger.info("📄 Auto track page view enabled (including SPA route tracking)");
+                // Record the initial path for SPA tracking
+                this.lastTrackedPath = this.getCurrentPath();
+                // Setup SPA tracking for route changes
+                this.setupSPATracking();
+                setTimeout(() => {
+                    // Fire asynchronously; do not block initialization
+                    this.trackPageView()
+                        .then(() => {
+                        this.logger.info("✅ Auto track page view completed");
+                    })
+                        .catch((error) => this.logger.error("❌ Auto track page view failed:", error));
+                }, 100);
+            }
+        }
+        catch (error) {
+            this.logger.error("Failed to initialize SDK:", error);
+            throw error;
+        }
+    }
+    // Track custom event
+    async trackEvent(eventType, eventData, tracking_user_id, revenue, currency = Currency.USD) {
+        if (!this.initialized) {
+            this.logger.warn("SDK not initialized, event not tracked");
+            return;
+        }
+        try {
+            const currentUrl = getCurrentUrl();
+            // Try to fetch public IP (best-effort)
+            let ip_address = null;
+            try {
+                ip_address = await this.fetchPublicIP();
+            }
+            catch (e) {
+                // ignore
+            }
+            const pageContext = {
+                domain: typeof window !== "undefined" ? window.location.hostname : null,
+                path: typeof window !== "undefined" ? window.location.pathname : null,
+                title: getPageTitle(),
+                referrer: getReferrer(),
+                url: currentUrl.split("?")[0],
+                querystring: getQueryString(currentUrl),
+                query_params: getQueryParams(currentUrl),
+                ip_address: ip_address,
+            };
+            const sessionContext = {
+                session_id: this.session?.sessionId,
+                start_time: this.session?.startTime,
+                last_activity: this.session?.lastActivity,
+                page_views: this.session?.pageViews,
+            };
+            const event = {
+                event_id: generateId(),
+                event_type: eventType,
+                tracking_user_id: tracking_user_id,
+                timestamp: getTimestamp(),
+                event_data: eventData,
+                context: { page: pageContext, session: sessionContext },
+                revenue: revenue,
+                currency: currency,
+                ...this.getUTMParams(),
+            };
+            this.logger.debug(`Tracking event: ${eventType}`, event);
+            // Add to queue
+            this.queue.add(event);
+        }
+        catch (error) {
+            this.logger.error(`Failed to track event ${eventType}:`, error);
+        }
+    }
+    // Track page view
+    async trackPageView(pageData, tracking_user_id) {
+        const currentUrl = getCurrentUrl();
+        // Use URL without query string as key for debouncing
+        const pageKey = currentUrl.split("?")[0];
+        const now = Date.now();
+        const debounceInterval = this.config.pageViewDebounceInterval || 5000;
+        // Check if this page was tracked recently
+        const lastTrackTime = this.pageViewTrackTimes.get(pageKey);
+        if (lastTrackTime && now - lastTrackTime < debounceInterval) {
+            this.logger.debug(`Page view debounced: ${pageKey} (last tracked ${now - lastTrackTime}ms ago)`);
+            return;
+        }
+        const pageEventData = {
+            url: currentUrl,
+            title: getPageTitle(),
+            referrer: getReferrer(),
+            user_agent: getUserAgent(),
+            ...pageData,
+        };
+        await this.trackEvent(EventType.PAGE_VIEW, pageEventData, tracking_user_id);
+        // Update last track time for this page
+        this.pageViewTrackTimes.set(pageKey, now);
+        // Clean up old entries to prevent memory leak (keep only entries from last hour)
+        this.cleanupPageViewTrackTimes();
+    }
+    // Clean up old page view track times to prevent memory leak
+    cleanupPageViewTrackTimes() {
+        const oneHourAgo = Date.now() - 60 * 60 * 1000;
+        for (const [pageKey, trackTime] of this.pageViewTrackTimes.entries()) {
+            if (trackTime < oneHourAgo) {
+                this.pageViewTrackTimes.delete(pageKey);
+            }
+        }
+    }
+    // Best-effort fetch of public IP address
+    async fetchPublicIP() {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            const response = await fetch("https://api.ipify.org?format=json", {
+                signal: controller.signal,
+                headers: { Accept: "application/json" },
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                return null;
+            }
+            const data = await response.json();
+            const ip = typeof data?.ip === "string" ? data.ip : null;
+            return ip;
+        }
+        catch (error) {
+            this.logger.debug("Public IP fetch failed", error);
+            return null;
+        }
+    }
+    // Track purchase
+    async trackPurchase(tracking_user_id, revenue, currency = Currency.USD, purchaseData) {
+        await this.trackEvent(EventType.PURCHASE, purchaseData, tracking_user_id, revenue, currency);
+    }
+    // Track login
+    async trackLogin(tracking_user_id, loginData) {
+        await this.trackEvent(EventType.LOGIN, loginData, tracking_user_id);
+    }
+    // Track signup
+    async trackSignup(tracking_user_id, signupData) {
+        await this.trackEvent(EventType.SIGNUP, signupData, tracking_user_id);
+    }
+    // Track form submission
+    async trackFormSubmit(tracking_user_id, formData) {
+        await this.trackEvent(EventType.FORM_SUBMIT, formData, tracking_user_id);
+    }
+    // Get attribution data
+    getAttributionData() {
+        return this.storage.getUTMData();
+    }
+    // Manually add UTM parameters to a URL
+    addUTMToURL(url) {
+        if (!this.config.enableCrossDomainUTM) {
+            return url;
+        }
+        const attributionData = this.getAttributionData();
+        if (!attributionData) {
+            return url;
+        }
+        const utmParams = filterUTMParams(attributionData.lastTouch, this.config.crossDomainUTMParams);
+        return addUTMToURL$1(url, utmParams);
+    }
+    // Get current UTM parameters as object
+    getCurrentUTMParams() {
+        const attributionData = this.getAttributionData();
+        if (!attributionData) {
+            return {};
+        }
+        return filterUTMParams(attributionData.lastTouch, this.config.crossDomainUTMParams);
+    }
+    // Get UTM parameters for events
+    getUTMParams() {
+        const attributionData = this.getAttributionData();
+        if (!attributionData) {
+            this.logger.debug("No attribution data available for UTM params");
+            return {};
+        }
+        const utmParams = {
+            utm_source: attributionData.lastTouch.utm_source || null,
+            utm_medium: attributionData.lastTouch.utm_medium || null,
+            utm_campaign: attributionData.lastTouch.utm_campaign || null,
+            utm_term: attributionData.lastTouch.utm_term || null,
+            utm_content: attributionData.lastTouch.utm_content || null,
+        };
+        // Filter out empty values and return null for empty strings
+        const filteredParams = {};
+        if (utmParams.utm_source && utmParams.utm_source.trim() !== "") {
+            filteredParams.utm_source = utmParams.utm_source;
+        }
+        else {
+            filteredParams.utm_source = null;
+        }
+        if (utmParams.utm_medium && utmParams.utm_medium.trim() !== "") {
+            filteredParams.utm_medium = utmParams.utm_medium;
+        }
+        else {
+            filteredParams.utm_medium = null;
+        }
+        if (utmParams.utm_campaign && utmParams.utm_campaign.trim() !== "") {
+            filteredParams.utm_campaign = utmParams.utm_campaign;
+        }
+        else {
+            filteredParams.utm_campaign = null;
+        }
+        if (utmParams.utm_term && utmParams.utm_term.trim() !== "") {
+            filteredParams.utm_term = utmParams.utm_term;
+        }
+        else {
+            filteredParams.utm_term = null;
+        }
+        if (utmParams.utm_content && utmParams.utm_content.trim() !== "") {
+            filteredParams.utm_content = utmParams.utm_content;
+        }
+        else {
+            filteredParams.utm_content = null;
+        }
+        this.logger.debug("UTM params for event:", filteredParams);
+        return filteredParams;
+    }
+    // Initialize user session
+    initializeSession() {
+        const existingSession = this.storage.getSession();
+        const now = Date.now();
+        if (existingSession &&
+            now - existingSession.lastActivity < this.config.sessionTimeout) {
+            // Extend existing session
+            this.session = {
+                ...existingSession,
+                lastActivity: now,
+            };
+        }
+        else {
+            // Create new session
+            this.session = {
+                sessionId: generateSessionId(),
+                startTime: now,
+                lastActivity: now,
+                pageViews: 0,
+            };
+        }
+        this.storage.storeSession(this.session);
+        this.logger.debug("Session initialized:", this.session);
+    }
+    // Extract and store UTM data from current URL
+    extractAndStoreUTMData() {
+        const currentUrl = getCurrentUrl();
+        const utmParams = extractUTMParams(currentUrl);
+        this.logger.debug("Extracting UTM params from URL:", currentUrl);
+        this.logger.debug("Found UTM params:", utmParams);
+        if (Object.keys(utmParams).length === 0) {
+            this.logger.debug("No UTM parameters found in URL");
+            return;
+        }
+        const utmData = {
+            utm_source: utmParams.utm_source || "",
+            utm_medium: utmParams.utm_medium || "",
+            utm_campaign: utmParams.utm_campaign || "",
+            utm_term: utmParams.utm_term || "",
+            utm_content: utmParams.utm_content || "",
+            timestamp: Date.now(),
+        };
+        const existingData = this.getAttributionData();
+        const newData = {
+            firstTouch: existingData?.firstTouch || utmData,
+            lastTouch: utmData,
+            touchpoints: existingData?.touchpoints || [],
+            expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
+        };
+        // Add to touchpoints if different from last touch
+        if (!existingData ||
+            existingData.lastTouch.utm_source !== utmData.utm_source ||
+            existingData.lastTouch.utm_campaign !== utmData.utm_campaign) {
+            newData.touchpoints.push(utmData);
+        }
+        this.storage.storeUTMData(newData);
+        this.logger.info("UTM data extracted and stored successfully:", utmData);
+        // Clean URL after storing UTM data to avoid displaying parameters in plain text
+        if (this.config.autoCleanUTM) {
+            cleanURL();
+        }
+    }
+    // Setup auto-tracking
+    setupAutoTracking() {
+        this.autoTrackEnabled = true;
+        // Track form interactions
+        this.setupFormTracking();
+        // Track link clicks
+        this.setupLinkTracking();
+        this.logger.info("Auto-tracking enabled");
+    }
+    // Setup form tracking
+    setupFormTracking() {
+        document.addEventListener("submit", (event) => {
+            try {
+                const form = event.target;
+                if (!form) {
+                    return;
+                }
+                const fieldValues = this.serializeFormFields(form);
+                this.trackEvent(EventType.FORM_SUBMIT, {
+                    ...fieldValues,
+                    form_id: form.id || form.name,
+                    form_action: form.action,
+                    form_method: form.method,
+                });
+            }
+            catch (error) {
+                this.logger.error("Failed to auto-track form submit:", error);
+            }
+        });
+    }
+    // Serialize all fields within a form to a flat key-value map
+    serializeFormFields(form) {
+        const result = {};
+        try {
+            const formData = new FormData(form);
+            // Accumulate multiple values for the same name as arrays
+            for (const [name, value] of formData.entries()) {
+                const serializedValue = this.serializeFormValue(value);
+                if (Object.prototype.hasOwnProperty.call(result, name)) {
+                    const existing = result[name];
+                    if (Array.isArray(existing)) {
+                        existing.push(serializedValue);
+                        result[name] = existing;
+                    }
+                    else {
+                        result[name] = [existing, serializedValue];
+                    }
+                }
+                else {
+                    result[name] = serializedValue;
+                }
+            }
+            // Ensure all named fields are represented, including unchecked radios/checkboxes
+            const elements = Array.from(form.elements);
+            // Group elements by name
+            const nameToElements = new Map();
+            for (const el of elements) {
+                const name = el.name;
+                if (!name || el.disabled)
+                    continue;
+                if (!nameToElements.has(name))
+                    nameToElements.set(name, []);
+                nameToElements.get(name).push(el);
+            }
+            nameToElements.forEach((els, name) => {
+                // Determine the dominant type for a group (radio/checkbox take precedence)
+                const hasRadio = els.some((e) => e.type === "radio");
+                const hasCheckbox = els.some((e) => e.type === "checkbox");
+                const hasFile = els.some((e) => e.type === "file");
+                const hasSelectMultiple = els.some((e) => e.tagName === "SELECT" && e.multiple);
+                const hasPassword = els.some((e) => e.type === "password");
+                if (hasCheckbox) {
+                    const checkedValues = els
+                        .filter((e) => e.type === "checkbox")
+                        .filter((e) => e.checked)
+                        .map((e) => e.value || "on");
+                    if (!Object.prototype.hasOwnProperty.call(result, name)) {
+                        result[name] = checkedValues; // [] when none checked
+                    }
+                    else if (!Array.isArray(result[name])) {
+                        result[name] = [result[name], ...checkedValues];
+                    }
+                    return;
+                }
+                if (hasRadio) {
+                    const checked = els
+                        .filter((e) => e.type === "radio")
+                        .find((e) => e.checked);
+                    if (!Object.prototype.hasOwnProperty.call(result, name)) {
+                        result[name] = checked ? checked.value : null;
+                    }
+                    return;
+                }
+                if (hasSelectMultiple) {
+                    const select = els.find((e) => e.tagName === "SELECT" && e.multiple);
+                    if (select) {
+                        const selectedValues = Array.from(select.selectedOptions).map((opt) => opt.value);
+                        if (!Object.prototype.hasOwnProperty.call(result, name)) {
+                            result[name] = selectedValues; // [] when none selected
+                        }
+                        return;
+                    }
+                }
+                if (hasFile) {
+                    const input = els.find((e) => e.type === "file");
+                    if (input) {
+                        const files = input.files ? Array.from(input.files) : [];
+                        if (!Object.prototype.hasOwnProperty.call(result, name)) {
+                            result[name] = files.map((f) => this.serializeFormValue(f));
+                        }
+                        return;
+                    }
+                }
+                if (hasPassword) {
+                    // Mask password fields
+                    if (Object.prototype.hasOwnProperty.call(result, name)) {
+                        result[name] =
+                            typeof result[name] === "string" ? "*****" : result[name];
+                    }
+                    else {
+                        result[name] = "*****";
+                    }
+                    return;
+                }
+                // For other inputs/selects/textarea, ensure at least an entry exists
+                if (!Object.prototype.hasOwnProperty.call(result, name)) {
+                    const first = els[0];
+                    if (first.tagName === "SELECT") {
+                        const select = first;
+                        result[name] = select.multiple
+                            ? Array.from(select.selectedOptions).map((o) => o.value)
+                            : select.value;
+                    }
+                    else if (first.type) {
+                        result[name] = first.value ?? "";
+                    }
+                    else {
+                        result[name] = first.value ?? "";
+                    }
+                }
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to serialize form fields:", error);
+        }
+        return result;
+    }
+    // Convert FormData value to a serializable value
+    serializeFormValue(value) {
+        if (value instanceof File) {
+            return {
+                file_name: value.name,
+                file_size: value.size,
+                file_type: value.type,
+            };
+        }
+        return value;
+    }
+    // Setup link tracking
+    setupLinkTracking() {
+        document.addEventListener("click", (event) => {
+            const target = event.target;
+            const link = target.closest("a");
+            if (link) {
+                const href = link.href;
+                const isExternal = isExternalURL(href);
+                if (isExternal) {
+                    // Handle cross-domain UTM passing
+                    this.handleCrossDomainUTM(link, event);
+                }
+            }
+        });
+    }
+    // Handle cross-domain UTM parameter passing
+    handleCrossDomainUTM(link, event) {
+        if (!this.config.enableCrossDomainUTM) {
+            return;
+        }
+        const href = link.href;
+        // Check if domain should be excluded
+        if (shouldExcludeDomain(href, this.config.excludeDomains)) {
+            this.logger.debug(`Domain excluded from UTM passing: ${href}`);
+            return;
+        }
+        // Get current UTM data
+        const attributionData = this.getAttributionData();
+        if (!attributionData) {
+            this.logger.debug("No UTM data available for cross-domain passing");
+            return;
+        }
+        // Filter UTM parameters based on configuration
+        const utmParams = filterUTMParams(attributionData.lastTouch, this.config.crossDomainUTMParams);
+        if (Object.keys(utmParams).length === 0) {
+            this.logger.debug("No UTM parameters to pass");
+            return;
+        }
+        // Add UTM parameters to URL
+        const enhancedURL = addUTMToURL$1(href, utmParams);
+        if (enhancedURL !== href) {
+            // Update the link href
+            link.href = enhancedURL;
+            this.logger.debug("UTM parameters added to external link:", {
+                original: href,
+                enhanced: enhancedURL,
+                utmParams,
+            });
+            this.logger.debug("Cross-domain UTM passed:", {
+                link_url: enhancedURL,
+                original_url: href,
+                utm_params_passed: utmParams,
+            });
+        }
+    }
+    // Setup network handlers
+    setupNetworkHandlers() {
+        window.addEventListener("online", () => {
+            this.logger.info("Network connection restored");
+            this.queue.flush();
+        });
+        window.addEventListener("offline", () => {
+            this.logger.warn("Network connection lost");
+        });
+    }
+    // Setup visibility handlers
+    setupVisibilityHandlers() {
+        document.addEventListener("visibilitychange", () => {
+            if (document.visibilityState === "visible") {
+                this.updateSessionActivity();
+            }
+        });
+    }
+    // Setup beforeunload handler
+    setupBeforeUnloadHandler() {
+        window.addEventListener("beforeunload", () => {
+            this.updateSessionActivity();
+            this.queue.flush();
+        });
+    }
+    // Get current path (pathname + search) for comparison
+    getCurrentPath() {
+        if (typeof window === "undefined")
+            return "";
+        return window.location.pathname + window.location.search;
+    }
+    // Setup SPA (Single Page Application) route tracking
+    setupSPATracking() {
+        if (typeof window === "undefined" || typeof history === "undefined") {
+            this.logger.warn("⚠️ SPA tracking not available in this environment");
+            return;
+        }
+        if (this.spaTrackingEnabled) {
+            this.logger.warn("⚠️ SPA tracking already enabled");
+            return;
+        }
+        this.spaTrackingEnabled = true;
+        this.lastTrackedPath = this.getCurrentPath();
+        // Store original methods
+        this.originalPushState = history.pushState.bind(history);
+        this.originalReplaceState = history.replaceState.bind(history);
+        // Create a handler for route changes
+        const handleRouteChange = (changeType) => {
+            const newPath = this.getCurrentPath();
+            // Only track if path actually changed
+            if (newPath === this.lastTrackedPath) {
+                this.logger.debug(`🔄 [SPA] Route change detected (${changeType}) but path unchanged: ${newPath}`);
+                return;
+            }
+            this.logger.debug(`🔄 [SPA] Route change detected (${changeType}): ${this.lastTrackedPath} -> ${newPath}`);
+            this.lastTrackedPath = newPath;
+            // Delay tracking to allow page title and content to update (100ms is sufficient for most frameworks)
+            setTimeout(() => {
+                this.trackPageView()
+                    .then(() => {
+                    this.logger.debug(`✅ [SPA] Page view tracked for: ${newPath}`);
+                })
+                    .catch((error) => {
+                    this.logger.error(`❌ [SPA] Failed to track page view:`, error);
+                });
+            }, 100);
+        };
+        // Override history.pushState
+        history.pushState = (data, unused, url) => {
+            const result = this.originalPushState(data, unused, url);
+            handleRouteChange("pushState");
+            return result;
+        };
+        // Override history.replaceState
+        history.replaceState = (data, unused, url) => {
+            const result = this.originalReplaceState(data, unused, url);
+            handleRouteChange("replaceState");
+            return result;
+        };
+        // Listen for popstate (browser back/forward)
+        this.popstateHandler = () => {
+            handleRouteChange("popstate");
+        };
+        window.addEventListener("popstate", this.popstateHandler);
+        this.logger.info("🔄 SPA tracking setup completed");
+    }
+    // Cleanup SPA tracking (restore original methods)
+    cleanupSPATracking() {
+        if (!this.spaTrackingEnabled)
+            return;
+        // Restore original history methods
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+            this.originalPushState = null;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+            this.originalReplaceState = null;
+        }
+        // Remove popstate listener
+        if (this.popstateHandler) {
+            window.removeEventListener("popstate", this.popstateHandler);
+            this.popstateHandler = null;
+        }
+        this.spaTrackingEnabled = false;
+        this.logger.info("🔄 SPA tracking cleaned up");
+    }
+    // Update session activity
+    updateSessionActivity() {
+        if (this.session) {
+            this.session.lastActivity = Date.now();
+            this.storage.storeSession(this.session);
+        }
+    }
+    // Flush all pending events
+    async flush() {
+        await this.queue.flush();
+    }
+    // Get SDK status
+    getStatus() {
+        return {
+            initialized: this.initialized,
+            session: this.session,
+            queueSize: this.queue.size(),
+            online: isOnline(),
+            crossDomainUTM: {
+                enabled: this.config.enableCrossDomainUTM || true,
+                currentParams: this.getCurrentUTMParams(),
+            },
+            spaTracking: {
+                enabled: this.spaTrackingEnabled,
+                currentPath: this.lastTrackedPath,
+            },
+        };
+    }
+    // Destroy SDK instance
+    destroy() {
+        this.queue.clear();
+        this.autoTrackEnabled = false;
+        this.cleanupSPATracking();
+        this.initialized = false;
+        this.logger.info("🗑️ SDK destroyed");
+    }
+}
+
+// Global SDK instance
+let globalSDK = null;
+// Auto-initialization function
+function autoInit() {
+    // Check if SDK is already initialized
+    if (globalSDK) {
+        return;
+    }
+    // Look for configuration in script tag
+    const script = document.currentScript;
+    if (!script) {
+        console.warn("GetuAI SDK: Could not find script tag for auto-initialization");
+        return;
+    }
+    const apiKey = script.getAttribute("data-api-key");
+    if (!apiKey) {
+        console.warn("GetuAI SDK: No API key provided. Please add data-api-key attribute to script tag.");
+        return;
+    }
+    const apiEndpoint = script.getAttribute("data-api-endpoint") || defaultEndpoint;
+    const config = {
+        apiKey,
+        apiEndpoint,
+        enableDebug: script.getAttribute("data-debug") === "true",
+        autoTrack: script.getAttribute("data-auto-track") === "true",
+        autoTrackPageView: script.getAttribute("data-auto-track-page-view") === "true",
+        autoCleanUTM: script.getAttribute("data-auto-clean-utm") !== "false",
+        batchSize: parseInt(script.getAttribute("data-batch-size") || "100"),
+        batchInterval: parseInt(script.getAttribute("data-batch-interval") || "5000"),
+    };
+    // Initialize SDK
+    init(config);
+}
+// Initialize SDK with configuration
+async function init(config) {
+    if (globalSDK) {
+        console.warn("GetuAI SDK: Already initialized");
+        return globalSDK;
+    }
+    try {
+        globalSDK = new AttributionSDK(config);
+        await globalSDK.init();
+        // Expose SDK to global scope for debugging
+        if (config.enableDebug) {
+            window.GetuAISDK = globalSDK;
+        }
+        console.log("GetuAI Attribution SDK initialized successfully");
+        // Dispatch initialization complete event
+        if (typeof window !== "undefined") {
+            const event = new CustomEvent("getuaiSDKReady", {
+                detail: { sdk: globalSDK },
+            });
+            window.dispatchEvent(event);
+        }
+        return globalSDK;
+    }
+    catch (error) {
+        console.error("GetuAI SDK: Failed to initialize:", error);
+        // Dispatch initialization error event
+        if (typeof window !== "undefined") {
+            const event = new CustomEvent("getuaiSDKError", {
+                detail: { error },
+            });
+            window.dispatchEvent(event);
+        }
+        throw error;
+    }
+}
+// Get current SDK instance
+function getSDK() {
+    return globalSDK;
+}
+// Wait for SDK to be ready
+function waitForSDK() {
+    return new Promise((resolve, reject) => {
+        if (globalSDK) {
+            resolve(globalSDK);
+            return;
+        }
+        // Listen for SDK ready event
+        const handleReady = (event) => {
+            window.removeEventListener("getuaiSDKReady", handleReady);
+            window.removeEventListener("getuaiSDKError", handleError);
+            resolve(event.detail.sdk);
+        };
+        const handleError = (event) => {
+            window.removeEventListener("getuaiSDKReady", handleReady);
+            window.removeEventListener("getuaiSDKError", handleError);
+            reject(event.detail.error);
+        };
+        window.addEventListener("getuaiSDKReady", handleReady);
+        window.addEventListener("getuaiSDKError", handleError);
+        // Timeout after 10 seconds
+        setTimeout(() => {
+            window.removeEventListener("getuaiSDKReady", handleReady);
+            window.removeEventListener("getuaiSDKError", handleError);
+            reject(new Error("SDK initialization timeout"));
+        }, 10000);
+    });
+}
+// Track event
+async function trackEvent(eventType, eventData, tracking_user_id, revenue, currency = Currency.USD) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackEvent(eventType, eventData, tracking_user_id, revenue, currency);
+}
+// Track page view
+async function trackPageView(pageData, tracking_user_id) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackPageView(pageData, tracking_user_id);
+}
+// Track purchase
+async function trackPurchase(tracking_user_id, revenue, currency = Currency.USD, purchaseData) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackPurchase(tracking_user_id, revenue, currency, purchaseData);
+}
+// Track login
+async function trackLogin(tracking_user_id, loginData) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackLogin(tracking_user_id, loginData);
+}
+// Track signup
+async function trackSignup(tracking_user_id, signupData) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackSignup(tracking_user_id, signupData);
+}
+// Track form submission
+async function trackFormSubmit(tracking_user_id, formData) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.trackFormSubmit(tracking_user_id, formData);
+}
+// Get attribution data
+function getAttributionData() {
+    const sdk = getSDK();
+    if (!sdk) {
+        return null;
+    }
+    return sdk.getAttributionData();
+}
+// Flush pending events
+async function flush() {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return;
+    }
+    await sdk.flush();
+}
+// Get SDK status
+function getStatus() {
+    const sdk = getSDK();
+    if (!sdk) {
+        return null;
+    }
+    return sdk.getStatus();
+}
+// Add UTM to URL
+function addUTMToURL(url) {
+    const sdk = getSDK();
+    if (!sdk) {
+        console.warn("GetuAI SDK: Not initialized. Call init() first.");
+        return url;
+    }
+    return sdk.addUTMToURL(url);
+}
+// Get current UTM parameters
+function getCurrentUTMParams() {
+    const sdk = getSDK();
+    if (!sdk) {
+        return {};
+    }
+    return sdk.getCurrentUTMParams();
+}
+// Destroy SDK
+function destroy() {
+    if (globalSDK) {
+        globalSDK.destroy();
+        globalSDK = null;
+        console.log("GetuAI SDK destroyed");
+    }
+}
+// Extend AttributionSDK class with static methods
+class AttributionSDKStatic extends AttributionSDK {
+    // Static method to initialize SDK
+    static async init(config) {
+        return await init(config);
+    }
+    // Static method to track event
+    static async trackEvent(eventType, eventData, tracking_user_id, revenue, currency = Currency.USD) {
+        return await trackEvent(eventType, eventData, tracking_user_id, revenue, currency);
+    }
+    // Static method to track page view
+    static async trackPageView(pageData, tracking_user_id) {
+        return await trackPageView(pageData, tracking_user_id);
+    }
+    // Static method to track purchase
+    static async trackPurchase(tracking_user_id, revenue, currency = Currency.USD, purchaseData) {
+        return await trackPurchase(tracking_user_id, revenue, currency, purchaseData);
+    }
+    // Static method to track login
+    static async trackLogin(tracking_user_id, loginData) {
+        return await trackLogin(tracking_user_id, loginData);
+    }
+    // Static method to track signup
+    static async trackSignup(tracking_user_id, signupData) {
+        return await trackSignup(tracking_user_id, signupData);
+    }
+    // Static method to track form submission
+    static async trackFormSubmit(tracking_user_id, formData) {
+        return await trackFormSubmit(tracking_user_id, formData);
+    }
+    // Static method to get attribution data
+    static getAttributionData() {
+        return getAttributionData();
+    }
+    // Static method to flush events
+    static async flush() {
+        return await flush();
+    }
+    // Static method to get status
+    static getStatus() {
+        return getStatus();
+    }
+    // Static method to add UTM to URL
+    static addUTMToURL(url) {
+        return addUTMToURL(url);
+    }
+    // Static method to get current UTM parameters
+    static getCurrentUTMParams() {
+        return getCurrentUTMParams();
+    }
+    // Static method to destroy SDK
+    static destroy() {
+        destroy();
+    }
+    // Static method to get SDK instance
+    static getSDK() {
+        return getSDK();
+    }
+    // Static method to wait for SDK
+    static waitForSDK() {
+        return waitForSDK();
+    }
+}
+// Auto-initialize if script is loaded with data-api-key
+if (typeof document !== "undefined") {
+    // Initialize immediately when script loads, don't wait for DOMContentLoaded
+    // This ensures SDK is ready before any body scripts execute
+    autoInit();
+}
+// Expose functions to global scope for browser usage
+if (typeof window !== "undefined") {
+    window.getuaiSDK = {
+        init,
+        getSDK,
+        waitForSDK,
+        trackEvent,
+        trackPageView,
+        trackPurchase,
+        trackLogin,
+        trackSignup,
+        trackFormSubmit,
+        getAttributionData,
+        flush,
+        getStatus,
+        addUTMToURL,
+        getCurrentUTMParams,
+        destroy,
+        EventType,
+        Currency,
+        AttributionSDK: AttributionSDKStatic, // 暴露带静态方法的AttributionSDK类
+    };
+    // Also expose individual functions for backward compatibility
+    window.init = init;
+    window.waitForSDK = waitForSDK;
+    window.trackEvent = trackEvent;
+    window.trackPageView = trackPageView;
+    window.trackPurchase = trackPurchase;
+    window.trackLogin = trackLogin;
+    window.trackSignup = trackSignup;
+    window.trackFormSubmit = trackFormSubmit;
+    window.getAttributionData = getAttributionData;
+    window.flush = flush;
+    window.getStatus = getStatus;
+    window.addUTMToURL = addUTMToURL;
+    window.getCurrentUTMParams = getCurrentUTMParams;
+    window.destroy = destroy;
+    window.AttributionSDK = AttributionSDKStatic; // 直接暴露带静态方法的AttributionSDK类
+}
+// Default export
+var index = {
+    init,
+    getSDK,
+    waitForSDK,
+    trackEvent,
+    trackPageView,
+    trackPurchase,
+    trackLogin,
+    trackSignup,
+    trackFormSubmit,
+    getAttributionData,
+    flush,
+    getStatus,
+    addUTMToURL,
+    getCurrentUTMParams,
+    destroy,
+    EventType,
+    Currency,
+    AttributionSDK: AttributionSDKStatic, // 包含带静态方法的AttributionSDK类
+};
+
+export { AttributionSDKStatic as AttributionSDK, Currency, EventType, addUTMToURL, index as default, destroy, flush, getAttributionData, getCurrentUTMParams, getSDK, getStatus, init, trackEvent, trackFormSubmit, trackLogin, trackPageView, trackPurchase, trackSignup, waitForSDK };
+//# sourceMappingURL=index.esm.js.map