@chip-hosting/analytics 1.0.0

package/dist/index.js

@@ -0,0 +1,1131 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+//# sourceMappingURL=index.js.map