getu-attribution-v2-sdk 0.1.0

package/dist/core/AttributionSDK.js

@@ -0,0 +1,709 @@
+import { EventType, Currency, defaultEndpoint, } from "../types";
+import { AttributionStorageManager } from "../storage";
+import { EventQueueManager, EventHttpClient } from "../queue";
+import { generateId, getTimestamp, extractUTMParams, getCurrentUrl, getReferrer, getUserAgent, getPageTitle, generateSessionId, isOnline, ConsoleLogger, addUTMToURL, shouldExcludeDomain, isExternalURL, filterUTMParams, cleanURL, getQueryString, getQueryParams, } from "../utils";
+export 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(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(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");
+    }
+}