@chip-hosting/analytics 1.0.0

package/dist/data-workbench-analytics.js

@@ -0,0 +1,1137 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.DataWorkbench = {}));
+})(this, (function (exports) { 'use strict';
+
+    const VISITOR_ID_KEY = '_dwb_vid';
+    const SESSION_ID_KEY = '_dwb_sid';
+    const USER_ID_KEY = '_dwb_uid';
+    // 2 years in seconds
+    const VISITOR_MAX_AGE = 2 * 365 * 24 * 60 * 60;
+    // 30 minutes in seconds
+    const SESSION_MAX_AGE = 30 * 60;
+    /**
+     * Generates a unique ID using crypto.randomUUID if available,
+     * otherwise falls back to a simple random string
+     */
+    function generateId(prefix) {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return `${prefix}_${crypto.randomUUID().replace(/-/g, '')}`;
+        }
+        // Fallback for older browsers
+        const random = Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15);
+        return `${prefix}_${random}`;
+    }
+    /**
+     * Cookie-based storage adapter
+     */
+    class CookieStorage {
+        constructor(domain) {
+            this.domain = domain;
+        }
+        get(key) {
+            if (typeof document === 'undefined')
+                return null;
+            const cookies = document.cookie.split(';');
+            for (const cookie of cookies) {
+                const [name, value] = cookie.trim().split('=');
+                if (name === key) {
+                    return decodeURIComponent(value);
+                }
+            }
+            return null;
+        }
+        set(key, value, options = {}) {
+            if (typeof document === 'undefined')
+                return;
+            const parts = [
+                `${key}=${encodeURIComponent(value)}`,
+            ];
+            if (options.maxAge !== undefined) {
+                parts.push(`max-age=${options.maxAge}`);
+            }
+            const domain = options.domain || this.domain;
+            if (domain) {
+                parts.push(`domain=${domain}`);
+            }
+            parts.push('path=/');
+            if (options.secure !== false) {
+                parts.push('secure');
+            }
+            const sameSite = options.sameSite || 'None';
+            parts.push(`samesite=${sameSite}`);
+            document.cookie = parts.join('; ');
+        }
+        remove(key) {
+            this.set(key, '', { maxAge: -1 });
+        }
+    }
+    /**
+     * Manages visitor and session identities via cookies
+     */
+    class CookieManager {
+        constructor(domain, storage) {
+            this.visitorId = null;
+            this.sessionId = null;
+            this.userId = null;
+            this.storage = storage || new CookieStorage(domain);
+            this.initialize();
+        }
+        /**
+         * Initialize visitor and session IDs
+         */
+        initialize() {
+            // Get or create visitor ID
+            this.visitorId = this.storage.get(VISITOR_ID_KEY);
+            if (!this.visitorId) {
+                this.visitorId = generateId('v');
+                this.storage.set(VISITOR_ID_KEY, this.visitorId, {
+                    maxAge: VISITOR_MAX_AGE,
+                    sameSite: 'None',
+                    secure: true,
+                });
+            }
+            // Get or create session ID
+            this.sessionId = this.storage.get(SESSION_ID_KEY);
+            if (!this.sessionId) {
+                this.sessionId = generateId('sess');
+            }
+            // Always refresh session cookie to extend expiration
+            this.storage.set(SESSION_ID_KEY, this.sessionId, {
+                maxAge: SESSION_MAX_AGE,
+                sameSite: 'None',
+                secure: true,
+            });
+            // Get existing user ID if any
+            this.userId = this.storage.get(USER_ID_KEY);
+        }
+        /**
+         * Get current visitor ID
+         */
+        getVisitorId() {
+            return this.visitorId;
+        }
+        /**
+         * Get current session ID
+         */
+        getSessionId() {
+            return this.sessionId;
+        }
+        /**
+         * Get current user ID (if identified)
+         */
+        getUserId() {
+            return this.userId;
+        }
+        /**
+         * Set user ID (after login/identification)
+         */
+        setUserId(userId) {
+            this.userId = userId;
+            this.storage.set(USER_ID_KEY, userId, {
+                maxAge: VISITOR_MAX_AGE,
+                sameSite: 'None',
+                secure: true,
+            });
+        }
+        /**
+         * Clear user ID (after logout)
+         */
+        clearUserId() {
+            this.userId = null;
+            this.storage.remove(USER_ID_KEY);
+        }
+        /**
+         * Start a new session
+         */
+        newSession() {
+            this.sessionId = generateId('sess');
+            this.storage.set(SESSION_ID_KEY, this.sessionId, {
+                maxAge: SESSION_MAX_AGE,
+                sameSite: 'None',
+                secure: true,
+            });
+        }
+        /**
+         * Refresh session (extend expiration)
+         */
+        refreshSession() {
+            if (this.sessionId) {
+                this.storage.set(SESSION_ID_KEY, this.sessionId, {
+                    maxAge: SESSION_MAX_AGE,
+                    sameSite: 'None',
+                    secure: true,
+                });
+            }
+        }
+        /**
+         * Reset all identities (for testing/debugging)
+         */
+        reset() {
+            this.storage.remove(VISITOR_ID_KEY);
+            this.storage.remove(SESSION_ID_KEY);
+            this.storage.remove(USER_ID_KEY);
+            this.visitorId = null;
+            this.sessionId = null;
+            this.userId = null;
+            this.initialize();
+        }
+    }
+
+    const DEFAULT_TIMEOUT = 10000; // 10 seconds
+    const DEFAULT_MAX_RETRIES = 3;
+    const RETRY_BASE_DELAY = 1000; // 1 second
+    /**
+     * HTTP transport layer for sending analytics data to Sensor
+     */
+    class HttpTransport {
+        constructor(config) {
+            this.endpoint = config.endpoint.replace(/\/$/, ''); // Remove trailing slash
+            this.clientId = config.clientId;
+            this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+            this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+            this.debug = config.debug ?? false;
+            this.useProxy = config.useProxy ?? false;
+            this.proxyEndpoint = config.proxyEndpoint?.replace(/\/$/, '');
+        }
+        /**
+         * Send a single event
+         */
+        async sendEvent(event, visitorId, sessionId, userId, identities) {
+            const url = this.getCollectUrl();
+            const headers = this.buildHeaders(visitorId, sessionId, userId, identities);
+            return this.sendWithRetry(url, event, headers);
+        }
+        /**
+         * Send a batch of events
+         */
+        async sendBatch(batch) {
+            const url = this.getBatchUrl();
+            const headers = this.buildHeaders(batch.visitorId, batch.sessionId, null, batch.identities);
+            return this.sendWithRetry(url, batch, headers);
+        }
+        /**
+         * Get the appropriate collect URL based on proxy setting
+         */
+        getCollectUrl() {
+            if (this.useProxy && this.proxyEndpoint) {
+                return `${this.proxyEndpoint}/collect`;
+            }
+            return `${this.endpoint}/collect`;
+        }
+        /**
+         * Get the appropriate batch URL based on proxy setting
+         */
+        getBatchUrl() {
+            if (this.useProxy && this.proxyEndpoint) {
+                return `${this.proxyEndpoint}/collect/batch`;
+            }
+            return `${this.endpoint}/collect/batch`;
+        }
+        /**
+         * Build headers for the request
+         */
+        buildHeaders(visitorId, sessionId, userId, identities) {
+            const headers = {
+                'Content-Type': 'application/json',
+                'X-Client-ID': this.clientId,
+                'X-Visitor-ID': visitorId,
+                'X-Session-ID': sessionId,
+            };
+            if (userId) {
+                headers['X-User-Id'] = userId;
+            }
+            if (identities.emails && identities.emails.length > 0) {
+                headers['X-Email'] = identities.emails[0];
+            }
+            if (identities.customerIds && identities.customerIds.length > 0) {
+                headers['X-Customer-Id'] = identities.customerIds[0];
+            }
+            if (identities.deviceIds && identities.deviceIds.length > 0) {
+                headers['X-Device-Id'] = identities.deviceIds[0];
+            }
+            return headers;
+        }
+        /**
+         * Send request with retry logic and exponential backoff
+         */
+        async sendWithRetry(url, payload, headers, attempt = 0) {
+            try {
+                const response = await this.fetchWithTimeout(url, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(payload),
+                    credentials: 'include', // Include cookies for cross-origin
+                });
+                if (response.ok) {
+                    this.log('Event sent successfully', { url, attempt });
+                    return { success: true, statusCode: response.status };
+                }
+                // Don't retry client errors (4xx) except 429 (rate limit)
+                if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                    const errorText = await response.text().catch(() => 'Unknown error');
+                    this.log('Client error, not retrying', { status: response.status, error: errorText });
+                    return {
+                        success: false,
+                        statusCode: response.status,
+                        error: errorText,
+                    };
+                }
+                // Retry server errors (5xx) and rate limits (429)
+                if (attempt < this.maxRetries) {
+                    const delay = this.calculateBackoff(attempt, response.status === 429);
+                    this.log(`Retrying after ${delay}ms`, { attempt, status: response.status });
+                    await this.sleep(delay);
+                    return this.sendWithRetry(url, payload, headers, attempt + 1);
+                }
+                return {
+                    success: false,
+                    statusCode: response.status,
+                    error: `Max retries exceeded (${this.maxRetries})`,
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                // Retry network errors
+                if (attempt < this.maxRetries) {
+                    const delay = this.calculateBackoff(attempt, false);
+                    this.log(`Network error, retrying after ${delay}ms`, { attempt, error: errorMessage });
+                    await this.sleep(delay);
+                    return this.sendWithRetry(url, payload, headers, attempt + 1);
+                }
+                this.log('Failed after max retries', { error: errorMessage });
+                return {
+                    success: false,
+                    error: errorMessage,
+                };
+            }
+        }
+        /**
+         * Fetch with timeout using AbortController
+         */
+        async fetchWithTimeout(url, options) {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            try {
+                const response = await fetch(url, {
+                    ...options,
+                    signal: controller.signal,
+                });
+                return response;
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+        }
+        /**
+         * Calculate exponential backoff delay
+         */
+        calculateBackoff(attempt, isRateLimit) {
+            // For rate limits, use longer delays
+            const baseDelay = isRateLimit ? RETRY_BASE_DELAY * 2 : RETRY_BASE_DELAY;
+            // Exponential backoff with jitter
+            const exponentialDelay = baseDelay * Math.pow(2, attempt);
+            const jitter = Math.random() * 1000;
+            return Math.min(exponentialDelay + jitter, 30000); // Cap at 30 seconds
+        }
+        /**
+         * Sleep for specified milliseconds
+         */
+        sleep(ms) {
+            return new Promise((resolve) => setTimeout(resolve, ms));
+        }
+        /**
+         * Log messages in debug mode
+         */
+        log(message, data) {
+            if (this.debug) {
+                console.log(`[DataWorkbench] ${message}`, data ?? '');
+            }
+        }
+        /**
+         * Send beacon on page unload (best-effort, no retry)
+         */
+        sendBeacon(payload) {
+            if (typeof navigator === 'undefined' || !navigator.sendBeacon) {
+                return false;
+            }
+            const url = this.getBatchUrl();
+            const blob = new Blob([JSON.stringify(payload)], { type: 'application/json' });
+            try {
+                return navigator.sendBeacon(url, blob);
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+
+    const DEFAULT_BATCH_SIZE = 5;
+    const DEFAULT_FLUSH_INTERVAL = 5000; // 5 seconds
+    /**
+     * Event queue for batching analytics events
+     */
+    class EventQueue {
+        constructor(config) {
+            this.queue = [];
+            this.flushTimer = null;
+            this.isFlushing = false;
+            this.visitorId = '';
+            this.sessionId = '';
+            this.clientId = '';
+            this.identities = {};
+            this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+            this.flushInterval = config.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+            this.onFlush = config.onFlush;
+            this.onBeaconFlush = config.onBeaconFlush;
+            this.debug = config.debug ?? false;
+            // Set up page unload handler
+            if (typeof window !== 'undefined') {
+                window.addEventListener('beforeunload', () => this.flushSync());
+                window.addEventListener('pagehide', () => this.flushSync());
+                // Handle visibility change (e.g., switching tabs on mobile)
+                document.addEventListener('visibilitychange', () => {
+                    if (document.visibilityState === 'hidden') {
+                        this.flushSync();
+                    }
+                });
+            }
+        }
+        /**
+         * Set context for all events
+         */
+        setContext(visitorId, sessionId, clientId, identities) {
+            this.visitorId = visitorId;
+            this.sessionId = sessionId;
+            this.clientId = clientId;
+            this.identities = identities;
+        }
+        /**
+         * Update identities (e.g., after identify() call)
+         */
+        updateIdentities(identities) {
+            this.identities = { ...this.identities, ...identities };
+        }
+        /**
+         * Add an event to the queue
+         */
+        enqueue(event) {
+            this.queue.push(event);
+            this.log('Event enqueued', { eventType: event.eventType, queueSize: this.queue.length });
+            // Start or restart flush timer
+            this.scheduleFlush();
+            // Flush immediately if batch size reached
+            if (this.queue.length >= this.batchSize) {
+                this.log('Batch size reached, flushing');
+                this.flush();
+            }
+        }
+        /**
+         * Schedule a flush after the interval
+         */
+        scheduleFlush() {
+            if (this.flushTimer) {
+                return; // Timer already running
+            }
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                if (this.queue.length > 0) {
+                    this.log('Interval reached, flushing');
+                    this.flush();
+                }
+            }, this.flushInterval);
+        }
+        /**
+         * Flush queued events asynchronously
+         */
+        async flush() {
+            if (this.isFlushing || this.queue.length === 0) {
+                return;
+            }
+            this.isFlushing = true;
+            // Take current batch
+            const batch = this.queue.splice(0, this.batchSize);
+            this.log('Flushing batch', { count: batch.length });
+            try {
+                await this.onFlush(batch);
+                this.log('Flush successful');
+            }
+            catch (error) {
+                // Re-queue failed events (at the front)
+                this.log('Flush failed, re-queueing', { error });
+                this.queue.unshift(...batch.map(e => ({ ...e, retryCount: e.retryCount + 1 })));
+            }
+            finally {
+                this.isFlushing = false;
+            }
+            // Continue flushing if more events in queue
+            if (this.queue.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+        /**
+         * Flush synchronously using sendBeacon (for page unload)
+         */
+        flushSync() {
+            if (this.queue.length === 0 || !this.onBeaconFlush) {
+                return;
+            }
+            const events = this.queue.splice(0);
+            const payload = {
+                events: events.map(e => this.eventToPayload(e)),
+                clientId: this.clientId,
+                visitorId: this.visitorId,
+                sessionId: this.sessionId,
+                identities: this.identities,
+            };
+            const success = this.onBeaconFlush(payload);
+            this.log('Beacon flush', { success, count: events.length });
+            if (!success) {
+                // Restore events if beacon failed
+                this.queue.push(...events);
+            }
+        }
+        /**
+         * Convert internal event to API payload
+         */
+        eventToPayload(event) {
+            return {
+                eventType: event.eventType,
+                timestamp: event.timestamp,
+                properties: event.properties,
+                sessionId: event.sessionId,
+            };
+        }
+        /**
+         * Get current queue size
+         */
+        size() {
+            return this.queue.length;
+        }
+        /**
+         * Clear the queue (for testing)
+         */
+        clear() {
+            this.queue = [];
+            if (this.flushTimer) {
+                clearTimeout(this.flushTimer);
+                this.flushTimer = null;
+            }
+        }
+        /**
+         * Destroy the queue and clean up
+         */
+        destroy() {
+            this.clear();
+            if (typeof window !== 'undefined') {
+                window.removeEventListener('beforeunload', () => this.flushSync());
+                window.removeEventListener('pagehide', () => this.flushSync());
+            }
+        }
+        /**
+         * Log messages in debug mode
+         */
+        log(message, data) {
+            if (this.debug) {
+                console.log(`[DataWorkbench Queue] ${message}`, data ?? '');
+            }
+        }
+    }
+
+    const BROWSER_RULES = [
+        { name: 'Edge', pattern: /Edg(?:e|A|iOS)?\/(\d+[\d.]*)/ },
+        { name: 'Opera', pattern: /OPR\/(\d+[\d.]*)/ },
+        { name: 'Samsung Internet', pattern: /SamsungBrowser\/(\d+[\d.]*)/ },
+        { name: 'UC Browser', pattern: /UCBrowser\/(\d+[\d.]*)/ },
+        { name: 'Firefox', pattern: /Firefox\/(\d+[\d.]*)/ },
+        { name: 'Safari', pattern: /Version\/(\d+[\d.]*).*Safari/ },
+        { name: 'Chrome', pattern: /Chrome\/(\d+[\d.]*)/ },
+    ];
+    const OS_RULES = [
+        { name: 'iOS', pattern: /iPhone|iPad|iPod/, versionPattern: /OS (\d+[_.\d]*)/ },
+        { name: 'Android', pattern: /Android/, versionPattern: /Android (\d+[\d.]*)/ },
+        { name: 'ChromeOS', pattern: /CrOS/ },
+        { name: 'Windows', pattern: /Windows/, versionPattern: /Windows NT (\d+[\d.]*)/ },
+        { name: 'macOS', pattern: /Macintosh|Mac OS X/, versionPattern: /Mac OS X (\d+[_.\d]*)/ },
+        { name: 'Linux', pattern: /Linux/ },
+    ];
+    const WINDOWS_VERSION_MAP = {
+        '10.0': '10',
+        '6.3': '8.1',
+        '6.2': '8',
+        '6.1': '7',
+    };
+    function majorMinor(version) {
+        const parts = version.replace(/_/g, '.').split('.');
+        return parts.slice(0, 2).join('.');
+    }
+    /**
+     * Lightweight user agent parser. Zero dependencies.
+     * Covers ~95% of real-world browser traffic.
+     * Returns "Unknown" for unrecognized user agents.
+     */
+    function parseUserAgent(ua) {
+        const result = {
+            browser: 'Unknown',
+            browser_version: '',
+            os: 'Unknown',
+            os_version: '',
+            device_type: 'desktop',
+        };
+        if (!ua)
+            return result;
+        // Browser detection (order matters -- Edge/Opera before Chrome)
+        for (const rule of BROWSER_RULES) {
+            const match = ua.match(rule.pattern);
+            if (match) {
+                result.browser = rule.name;
+                result.browser_version = majorMinor(match[1]);
+                break;
+            }
+        }
+        // OS detection
+        for (const rule of OS_RULES) {
+            if (rule.pattern.test(ua)) {
+                result.os = rule.name;
+                if (rule.versionPattern) {
+                    const match = ua.match(rule.versionPattern);
+                    if (match) {
+                        let version = majorMinor(match[1]);
+                        if (rule.name === 'Windows' && WINDOWS_VERSION_MAP[version]) {
+                            version = WINDOWS_VERSION_MAP[version];
+                        }
+                        result.os_version = version;
+                    }
+                }
+                break;
+            }
+        }
+        // Device type detection
+        if (/iPad|tablet/i.test(ua) || (/Android/i.test(ua) && !/Mobile/i.test(ua))) {
+            result.device_type = 'tablet';
+        }
+        else if (/Mobile|iPhone|iPod|Android.*Mobile|webOS|BlackBerry|IEMobile|Opera Mini/i.test(ua)) {
+            result.device_type = 'mobile';
+        }
+        return result;
+    }
+
+    const UTM_KEYS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content'];
+    /**
+     * Extracts UTM parameters from a URL string.
+     * Returns only recognized UTM keys (source, medium, campaign, term, content).
+     */
+    function parseUtmParams(url) {
+        if (!url)
+            return {};
+        try {
+            const searchParams = new URL(url).searchParams;
+            const result = {};
+            for (const key of UTM_KEYS) {
+                const value = searchParams.get(key);
+                if (value) {
+                    result[key] = value;
+                }
+            }
+            return result;
+        }
+        catch {
+            return {};
+        }
+    }
+
+    /**
+     * Collects browser context and merges it into event properties.
+     *
+     * - Stable context (browser, OS, screen, language) is cached on first call.
+     * - Dynamic context (viewport, UTM, performance) is read fresh each call.
+     */
+    class ContextCollector {
+        constructor(config) {
+            this.stableContext = null;
+            if (typeof config === 'boolean') {
+                this.enabled = config;
+                this.categories = {
+                    screen: true,
+                    browser: true,
+                    locale: true,
+                    utm: true,
+                    device: true,
+                    performance: true,
+                    network: true,
+                };
+            }
+            else {
+                this.enabled = true;
+                this.categories = {
+                    screen: config.screen !== false,
+                    browser: config.browser !== false,
+                    locale: config.locale !== false,
+                    utm: config.utm !== false,
+                    device: config.device !== false,
+                    performance: config.performance !== false,
+                    network: config.network !== false,
+                };
+            }
+        }
+        /** Returns auto-collected context properties. */
+        getContext() {
+            if (!this.enabled)
+                return {};
+            if (!this.stableContext) {
+                this.stableContext = this.collectStableContext();
+            }
+            return { ...this.stableContext, ...this.collectDynamicContext() };
+        }
+        /** Merges auto-collected context under user-supplied properties. */
+        mergeContext(userProperties) {
+            const autoContext = this.getContext();
+            return { ...autoContext, ...userProperties };
+        }
+        collectStableContext() {
+            const ctx = {};
+            if (typeof window === 'undefined')
+                return ctx;
+            const win = window;
+            if (this.categories.screen) {
+                ctx.screen_size = `${win.screen.width}x${win.screen.height}`;
+                ctx.pixel_ratio = win.devicePixelRatio;
+                ctx.color_depth = win.screen.colorDepth;
+            }
+            if (this.categories.browser) {
+                const ua = parseUserAgent(win.navigator.userAgent);
+                ctx.browser = ua.browser;
+                ctx.browser_version = ua.browser_version;
+                ctx.os = ua.os;
+                ctx.os_version = ua.os_version;
+                ctx.device_type = ua.device_type;
+            }
+            if (this.categories.locale) {
+                ctx.language = win.navigator.language;
+                try {
+                    ctx.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                }
+                catch {
+                    // Intl not available
+                }
+            }
+            if (this.categories.device) {
+                ctx.touch_support = 'ontouchstart' in win;
+                ctx.cookie_enabled = win.navigator.cookieEnabled;
+                ctx.do_not_track = win.navigator.doNotTrack === '1' || win.navigator.doNotTrack === 'yes';
+                ctx.hardware_concurrency = win.navigator.hardwareConcurrency;
+                ctx.platform = win.navigator.platform;
+            }
+            return ctx;
+        }
+        collectDynamicContext() {
+            const ctx = {};
+            if (typeof window === 'undefined')
+                return ctx;
+            const win = window;
+            if (this.categories.screen) {
+                ctx.viewport_size = `${win.innerWidth}x${win.innerHeight}`;
+            }
+            if (this.categories.utm) {
+                const utms = parseUtmParams(win.location.href);
+                Object.assign(ctx, utms);
+            }
+            if (this.categories.performance) {
+                try {
+                    const entries = win.performance.getEntriesByType('navigation');
+                    if (entries.length > 0) {
+                        const nav = entries[0];
+                        if (nav.loadEventEnd > 0) {
+                            ctx.page_load_time = Math.round(nav.loadEventEnd - nav.startTime);
+                            ctx.dom_ready_time = Math.round(nav.domContentLoadedEventEnd - nav.startTime);
+                            ctx.navigation_type = nav.type;
+                        }
+                    }
+                }
+                catch {
+                    // Performance API not available
+                }
+            }
+            if (this.categories.network) {
+                const conn = win.navigator.connection;
+                if (conn?.effectiveType) {
+                    ctx.connection_type = conn.effectiveType;
+                }
+            }
+            return ctx;
+        }
+    }
+
+    /**
+     * Generate a unique event ID
+     */
+    function generateEventId() {
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        return Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15);
+    }
+    /**
+     * Main Analytics class - the core of the SDK
+     */
+    class Analytics {
+        constructor() {
+            this.config = null;
+            this.cookieManager = null;
+            this.transport = null;
+            this.queue = null;
+            this.identities = {};
+            this.initialized = false;
+            this.debug = false;
+            this.contextCollector = null;
+        }
+        /**
+         * Initialize the SDK with configuration
+         */
+        init(config) {
+            if (this.initialized) {
+                this.log('SDK already initialized, skipping');
+                return;
+            }
+            this.config = config;
+            this.debug = config.debug ?? false;
+            // Initialize cookie manager
+            this.cookieManager = new CookieManager(config.cookieDomain);
+            // Initialize identities
+            this.identities = {
+                anonymous: [this.cookieManager.getVisitorId()],
+            };
+            // Initialize transport
+            this.transport = new HttpTransport({
+                endpoint: config.endpoint,
+                clientId: config.clientId,
+                maxRetries: config.maxRetries,
+                debug: config.debug,
+                useProxy: config.useProxy,
+                proxyEndpoint: config.proxyEndpoint,
+            });
+            // Initialize queue
+            this.queue = new EventQueue({
+                batchSize: config.batchSize,
+                flushInterval: config.flushInterval,
+                debug: config.debug,
+                onFlush: async (events) => this.sendEvents(events),
+                onBeaconFlush: (payload) => this.transport.sendBeacon(payload),
+            });
+            // Set queue context
+            this.queue.setContext(this.cookieManager.getVisitorId(), this.cookieManager.getSessionId(), config.clientId, this.identities);
+            // Initialize context collector
+            this.contextCollector = new ContextCollector(config.autoCollect ?? true);
+            this.initialized = true;
+            this.log('SDK initialized', { endpoint: config.endpoint, clientId: config.clientId });
+        }
+        /**
+         * Track a custom event
+         */
+        track(eventType, properties = {}) {
+            this.ensureInitialized();
+            const mergedProperties = this.contextCollector?.mergeContext(properties) ?? properties;
+            const event = {
+                id: generateEventId(),
+                timestamp: Date.now(),
+                eventType,
+                properties: mergedProperties,
+                visitorId: this.cookieManager.getVisitorId(),
+                sessionId: this.cookieManager.getSessionId(),
+                userId: this.cookieManager.getUserId() ?? undefined,
+                identities: { ...this.identities },
+                retryCount: 0,
+            };
+            this.queue.enqueue(event);
+            this.cookieManager.refreshSession();
+        }
+        /**
+         * Track a page view
+         */
+        page(name, properties = {}) {
+            const pageProperties = {
+                ...properties,
+                url: typeof window !== 'undefined' ? window.location.href : undefined,
+                path: typeof window !== 'undefined' ? window.location.pathname : undefined,
+                referrer: typeof document !== 'undefined' ? document.referrer : undefined,
+                title: typeof document !== 'undefined' ? document.title : undefined,
+            };
+            if (name) {
+                pageProperties.name = name;
+            }
+            this.track('page_view', pageProperties);
+        }
+        /**
+         * Identify a user
+         */
+        identify(userId, traits = {}) {
+            this.ensureInitialized();
+            // Update cookie manager
+            this.cookieManager.setUserId(userId);
+            // Update identities
+            this.identities.authenticated = [userId];
+            if (traits.email) {
+                this.identities.emails = [traits.email.toLowerCase()];
+            }
+            if (traits.customerId) {
+                this.identities.customerIds = [traits.customerId];
+            }
+            if (traits.deviceId) {
+                this.identities.deviceIds = [traits.deviceId];
+            }
+            if (traits.phone) {
+                this.identities.phones = [traits.phone];
+            }
+            // Update queue context
+            this.queue.updateIdentities(this.identities);
+            // Track identify event
+            this.track('identify', { userId, ...traits });
+            this.log('User identified', { userId, traits });
+        }
+        /**
+         * Clear user identity (logout)
+         */
+        reset() {
+            this.ensureInitialized();
+            this.cookieManager.clearUserId();
+            this.cookieManager.newSession();
+            // Reset identities to anonymous only
+            this.identities = {
+                anonymous: [this.cookieManager.getVisitorId()],
+            };
+            // Update queue context
+            this.queue.setContext(this.cookieManager.getVisitorId(), this.cookieManager.getSessionId(), this.config.clientId, this.identities);
+            this.log('User reset');
+        }
+        /**
+         * Manually flush the event queue
+         */
+        async flush() {
+            this.ensureInitialized();
+            await this.queue.flush();
+        }
+        /**
+         * Get current visitor ID
+         */
+        getVisitorId() {
+            this.ensureInitialized();
+            return this.cookieManager.getVisitorId();
+        }
+        /**
+         * Get current session ID
+         */
+        getSessionId() {
+            this.ensureInitialized();
+            return this.cookieManager.getSessionId();
+        }
+        /**
+         * Get current user ID (if identified)
+         */
+        getUserId() {
+            this.ensureInitialized();
+            return this.cookieManager.getUserId();
+        }
+        /**
+         * Check if SDK is initialized
+         */
+        isInitialized() {
+            return this.initialized;
+        }
+        /**
+         * Destroy the SDK instance
+         */
+        destroy() {
+            if (this.queue) {
+                this.queue.destroy();
+            }
+            this.initialized = false;
+            this.config = null;
+            this.cookieManager = null;
+            this.transport = null;
+            this.queue = null;
+            this.contextCollector = null;
+            this.identities = {};
+        }
+        /**
+         * Send events to the Sensor
+         */
+        async sendEvents(events) {
+            if (!this.transport || !this.cookieManager) {
+                throw new Error('Transport not initialized');
+            }
+            // Send as batch
+            const payload = {
+                events: events.map((e) => this.eventToPayload(e)),
+                clientId: this.config.clientId,
+                visitorId: this.cookieManager.getVisitorId(),
+                sessionId: this.cookieManager.getSessionId(),
+                identities: this.identities,
+            };
+            const response = await this.transport.sendBatch(payload);
+            if (!response.success) {
+                throw new Error(response.error || 'Failed to send events');
+            }
+        }
+        /**
+         * Convert internal event to API payload
+         */
+        eventToPayload(event) {
+            return {
+                eventType: event.eventType,
+                timestamp: event.timestamp,
+                properties: event.properties,
+                sessionId: event.sessionId,
+            };
+        }
+        /**
+         * Ensure SDK is initialized before use
+         */
+        ensureInitialized() {
+            if (!this.initialized) {
+                throw new Error('DataWorkbench SDK not initialized. Call DataWorkbench.init() first.');
+            }
+        }
+        /**
+         * Log messages in debug mode
+         */
+        log(message, data) {
+            if (this.debug) {
+                console.log(`[DataWorkbench] ${message}`, data ?? '');
+            }
+        }
+    }
+
+    const SELECTOR = 'a, button, [role="button"], [data-track]';
+    /**
+     * Automatic click tracking plugin for the Data Workbench SDK.
+     *
+     * Listens for clicks on interactive elements (links, buttons, role="button",
+     * data-track) and fires a `click` event via the provided track function.
+     */
+    class ClickTracker {
+        constructor(trackFn) {
+            this.trackFn = trackFn;
+            this.handler = this.handleClick.bind(this);
+            document.addEventListener('click', this.handler, { capture: true });
+        }
+        destroy() {
+            if (this.handler) {
+                document.removeEventListener('click', this.handler, { capture: true });
+                this.handler = null;
+            }
+        }
+        handleClick(event) {
+            const target = event.target;
+            const clickable = target.closest?.(SELECTOR);
+            if (!clickable)
+                return;
+            const props = {
+                tagName: clickable.tagName.toLowerCase(),
+                text: (clickable.textContent || '').slice(0, 100).trim(),
+                classList: Array.from(clickable.classList).join(' '),
+            };
+            if (clickable.hasAttribute('data-track')) {
+                props.trackId = clickable.getAttribute('data-track');
+            }
+            if (clickable instanceof HTMLAnchorElement) {
+                props.href = clickable.href;
+                props.isExternal = clickable.hostname !== window.location.hostname;
+            }
+            if (clickable instanceof HTMLButtonElement) {
+                props.buttonType = clickable.type;
+                if (clickable.form) {
+                    props.formId = clickable.form.id || undefined;
+                    props.formAction = clickable.form.action || undefined;
+                }
+            }
+            this.trackFn('click', props);
+        }
+    }
+
+    // Create singleton instance for simple usage
+    const analytics = new Analytics();
+    /**
+     * DataWorkbench Analytics SDK
+     *
+     * Usage:
+     * ```typescript
+     * import DataWorkbench from '@data-workbench/analytics';
+     *
+     * DataWorkbench.init({
+     *   endpoint: 'https://sensor.yourcompany.com',
+     *   clientId: 'your-website'
+     * });
+     *
+     * DataWorkbench.track('button_click', { buttonId: 'signup' });
+     * DataWorkbench.identify('user123', { email: 'user@example.com' });
+     * DataWorkbench.page('/products');
+     * ```
+     */
+    const DataWorkbench = {
+        /**
+         * Initialize the SDK
+         */
+        init: analytics.init.bind(analytics),
+        /**
+         * Track a custom event
+         */
+        track: analytics.track.bind(analytics),
+        /**
+         * Track a page view
+         */
+        page: analytics.page.bind(analytics),
+        /**
+         * Identify a user
+         */
+        identify: analytics.identify.bind(analytics),
+        /**
+         * Reset user identity (logout)
+         */
+        reset: analytics.reset.bind(analytics),
+        /**
+         * Manually flush the event queue
+         */
+        flush: analytics.flush.bind(analytics),
+        /**
+         * Get current visitor ID
+         */
+        getVisitorId: analytics.getVisitorId.bind(analytics),
+        /**
+         * Get current session ID
+         */
+        getSessionId: analytics.getSessionId.bind(analytics),
+        /**
+         * Get current user ID
+         */
+        getUserId: analytics.getUserId.bind(analytics),
+        /**
+         * Check if SDK is initialized
+         */
+        isInitialized: analytics.isInitialized.bind(analytics),
+        /**
+         * Destroy the SDK instance
+         */
+        destroy: analytics.destroy.bind(analytics),
+    };
+    // For CDN/script tag usage - attach to window
+    if (typeof window !== 'undefined') {
+        window.DataWorkbench = DataWorkbench;
+    }
+
+    exports.Analytics = Analytics;
+    exports.ClickTracker = ClickTracker;
+    exports.ContextCollector = ContextCollector;
+    exports.CookieManager = CookieManager;
+    exports.CookieStorage = CookieStorage;
+    exports.DataWorkbench = DataWorkbench;
+    exports.EventQueue = EventQueue;
+    exports.HttpTransport = HttpTransport;
+    exports.default = DataWorkbench;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=data-workbench-analytics.js.map