@truxl/javascript-sdk 1.0.0

package/dist/truxl.esm.js

@@ -0,0 +1,1409 @@
+const DEFAULT_AUTOCAPTURE_CONFIG = {
+    pageview: 'full-url',
+    click: true,
+    dead_click: true,
+    input: true,
+    rage_click: true,
+    scroll: true,
+    submit: true,
+    capture_text_content: false,
+};
+const DEFAULT_CONFIG = {
+    apiEndpoint: 'https://ingestion.api.stage.truxl.com',
+    batchSize: 20,
+    flushInterval: 5000,
+    autocapture: false,
+    track_pageview: true,
+    debug: false,
+    maxQueueSize: 10000,
+    retryAttempts: 5,
+    retryBaseDelay: 1000,
+    transport: 'http',
+};
+/**
+ * Resolve the autocapture option into a full config object, or null if disabled.
+ */
+function resolveAutocaptureConfig(autocapture) {
+    if (!autocapture)
+        return null;
+    if (autocapture === true)
+        return { ...DEFAULT_AUTOCAPTURE_CONFIG };
+    return { ...DEFAULT_AUTOCAPTURE_CONFIG, ...autocapture };
+}
+
+class EventQueue {
+    constructor(config, transport) {
+        this.queue = [];
+        this.timer = null;
+        this.sending = false;
+        this.config = config;
+        this.transport = transport;
+        this.loadFromStorage();
+        this.startTimer();
+        if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', () => this.flush());
+        }
+    }
+    enqueue(event) {
+        if (this.queue.length >= this.config.maxQueueSize) {
+            this.queue.shift();
+        }
+        this.queue.push(event);
+        this.saveToStorage();
+        if (this.queue.length >= this.config.batchSize) {
+            this.flush();
+        }
+    }
+    async flush() {
+        if (this.sending || this.queue.length === 0)
+            return;
+        this.sending = true;
+        const batch = this.queue.splice(0, this.config.batchSize);
+        try {
+            const result = await this.transport.send({ events: batch });
+            if (!result.ok) {
+                // Only re-queue on transient errors (5xx / network failure).
+                // 4xx errors (401, 403, 422, etc.) are permanent — drop the batch.
+                const isTransient = result.status === 0 || result.status >= 500;
+                if (isTransient) {
+                    this.queue.unshift(...batch);
+                }
+            }
+            this.saveToStorage();
+        }
+        catch {
+            this.queue.unshift(...batch);
+            this.saveToStorage();
+        }
+        finally {
+            this.sending = false;
+        }
+    }
+    destroy() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.transport.destroy?.();
+    }
+    startTimer() {
+        this.timer = setInterval(() => this.flush(), this.config.flushInterval);
+    }
+    saveToStorage() {
+        if (typeof requestIdleCallback === 'function') {
+            requestIdleCallback(() => {
+                try {
+                    localStorage.setItem('truxl_queue', JSON.stringify(this.queue));
+                }
+                catch { }
+            });
+        }
+        else {
+            setTimeout(() => {
+                try {
+                    localStorage.setItem('truxl_queue', JSON.stringify(this.queue));
+                }
+                catch { }
+            }, 0);
+        }
+    }
+    loadFromStorage() {
+        try {
+            const stored = localStorage.getItem('truxl_queue');
+            if (stored) {
+                this.queue = JSON.parse(stored);
+            }
+        }
+        catch { }
+    }
+}
+
+async function signPayload(payload, secret) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const signature = await crypto.subtle.sign('HMAC', key, encoder.encode(payload));
+    return Array.from(new Uint8Array(signature))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+
+/**
+ * Fetch-based HTTP transport with exponential back-off retry.
+ *
+ * Retry delays follow the pattern: baseDelay * 2^attempt
+ *   attempt 0 -> 1 s
+ *   attempt 1 -> 2 s
+ *   attempt 2 -> 4 s
+ *   attempt 3 -> 8 s
+ *   ...
+ *   capped at MAX_RETRY_DELAY (60 s)
+ *
+ * Only 5xx (server) errors and network failures are retried. 4xx responses
+ * are treated as permanent failures and are NOT retried.
+ */
+/** Maximum delay between retries (in milliseconds). */
+const MAX_RETRY_DELAY = 60000;
+/**
+ * Low-level HTTP transport. Send a JSON payload to the Truxl ingestion
+ * endpoint with HMAC signing and automatic retry on transient errors.
+ */
+class HttpTransport {
+    constructor(options) {
+        this.config = options.config;
+    }
+    /**
+     * Send a JSON-serialisable payload to the batch endpoint.
+     *
+     * @param payload  The body to POST (will be JSON-stringified).
+     * @returns        A result object indicating success/failure and number of
+     *                 retries performed.
+     */
+    async send(payload) {
+        const body = JSON.stringify(payload);
+        return this.sendWithRetry(body, 0);
+    }
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+    async sendWithRetry(body, attempt) {
+        try {
+            const signature = await signPayload(body, this.config.clientSecret);
+            const response = await fetch(`${this.config.apiEndpoint}/v1/batch`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Project-Token': this.config.projectToken,
+                    'X-Signature': signature,
+                },
+                body,
+            });
+            if (response.ok) {
+                return { ok: true, status: response.status, retries: attempt };
+            }
+            // Only retry on server errors (5xx)
+            if (response.status >= 500 && attempt < this.config.retryAttempts) {
+                await this.wait(attempt);
+                return this.sendWithRetry(body, attempt + 1);
+            }
+            return { ok: false, status: response.status, retries: attempt };
+        }
+        catch {
+            // Network error -- retry if we haven't exhausted attempts
+            if (attempt < this.config.retryAttempts) {
+                await this.wait(attempt);
+                return this.sendWithRetry(body, attempt + 1);
+            }
+            return { ok: false, status: 0, retries: attempt };
+        }
+    }
+    /**
+     * Calculate the delay for a given retry attempt and sleep.
+     * delay = min(baseDelay * 2^attempt, MAX_RETRY_DELAY)
+     */
+    wait(attempt) {
+        const delay = Math.min(this.config.retryBaseDelay * Math.pow(2, attempt), MAX_RETRY_DELAY);
+        return new Promise((resolve) => setTimeout(resolve, delay));
+    }
+}
+
+const MAX_RECONNECT_DELAY = 30000;
+const INITIAL_RECONNECT_DELAY = 1000;
+class WebSocketTransport {
+    constructor(options) {
+        this.ws = null;
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.pendingMessages = [];
+        this.connected = false;
+        this.destroyed = false;
+        this.config = options.config;
+        this.connect();
+    }
+    async send(payload) {
+        const body = JSON.stringify(payload);
+        const signature = await signPayload(body, this.config.clientSecret);
+        const message = JSON.stringify({
+            token: this.config.projectToken,
+            signature,
+            payload: body,
+        });
+        if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(message);
+            return { ok: true, status: 200, retries: 0 };
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingMessages.push({ data: message, resolve, reject });
+        });
+    }
+    destroy() {
+        this.destroyed = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.onclose = null;
+            this.ws.close();
+            this.ws = null;
+        }
+        for (const msg of this.pendingMessages) {
+            msg.reject(new Error('Transport destroyed'));
+        }
+        this.pendingMessages = [];
+    }
+    connect() {
+        if (this.destroyed)
+            return;
+        const wsEndpoint = this.config.apiEndpoint
+            .replace(/^http/, 'ws') + '/ws/events';
+        this.ws = new WebSocket(wsEndpoint);
+        this.ws.onopen = () => {
+            this.connected = true;
+            this.reconnectAttempt = 0;
+            for (const msg of this.pendingMessages) {
+                this.ws.send(msg.data);
+                msg.resolve({ ok: true, status: 200, retries: 0 });
+            }
+            this.pendingMessages = [];
+        };
+        this.ws.onclose = () => {
+            this.connected = false;
+            this.scheduleReconnect();
+        };
+        this.ws.onerror = () => {
+            // onclose fires after onerror, reconnect handled there
+        };
+    }
+    scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        const delay = Math.min(INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempt), MAX_RECONNECT_DELAY);
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => this.connect(), delay);
+    }
+}
+
+/**
+ * Browser environment utilities.
+ * Gathers user-agent, screen size, referrer, viewport, language, and other
+ * contextual information that is attached to tracked events.
+ */
+/**
+ * Collect a snapshot of the current browser/page context.
+ * Every property access is wrapped so this function never throws, even in
+ * non-browser environments.
+ */
+function getBrowserInfo() {
+    return {
+        userAgent: getUserAgent(),
+        language: getLanguage(),
+        languages: getLanguages(),
+        screenWidth: getScreenWidth(),
+        screenHeight: getScreenHeight(),
+        viewportWidth: getViewportWidth(),
+        viewportHeight: getViewportHeight(),
+        devicePixelRatio: getDevicePixelRatio(),
+        referrer: getReferrer(),
+        url: getCurrentUrl(),
+        path: getCurrentPath(),
+        title: getPageTitle(),
+        hostname: getHostname(),
+        timezone: getTimezone(),
+        timezoneOffset: getTimezoneOffset(),
+        online: getOnlineStatus(),
+        cookiesEnabled: getCookiesEnabled(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Individual accessors
+// ---------------------------------------------------------------------------
+function getUserAgent() {
+    try {
+        return navigator.userAgent;
+    }
+    catch {
+        return '';
+    }
+}
+function getLanguage() {
+    try {
+        return navigator.language || '';
+    }
+    catch {
+        return '';
+    }
+}
+function getLanguages() {
+    try {
+        return navigator.languages ?? [getLanguage()];
+    }
+    catch {
+        return [];
+    }
+}
+function getScreenWidth() {
+    try {
+        return screen.width;
+    }
+    catch {
+        return 0;
+    }
+}
+function getScreenHeight() {
+    try {
+        return screen.height;
+    }
+    catch {
+        return 0;
+    }
+}
+function getViewportWidth() {
+    try {
+        return window.innerWidth;
+    }
+    catch {
+        return 0;
+    }
+}
+function getViewportHeight() {
+    try {
+        return window.innerHeight;
+    }
+    catch {
+        return 0;
+    }
+}
+function getDevicePixelRatio() {
+    try {
+        return window.devicePixelRatio ?? 1;
+    }
+    catch {
+        return 1;
+    }
+}
+function getReferrer() {
+    try {
+        return document.referrer;
+    }
+    catch {
+        return '';
+    }
+}
+function getCurrentUrl() {
+    try {
+        return window.location.href;
+    }
+    catch {
+        return '';
+    }
+}
+function getCurrentPath() {
+    try {
+        return window.location.pathname;
+    }
+    catch {
+        return '';
+    }
+}
+function getPageTitle() {
+    try {
+        return document.title;
+    }
+    catch {
+        return '';
+    }
+}
+function getHostname() {
+    try {
+        return window.location.hostname;
+    }
+    catch {
+        return '';
+    }
+}
+function getTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    catch {
+        return '';
+    }
+}
+function getTimezoneOffset() {
+    try {
+        return new Date().getTimezoneOffset();
+    }
+    catch {
+        return 0;
+    }
+}
+function getOnlineStatus() {
+    try {
+        return navigator.onLine;
+    }
+    catch {
+        return true;
+    }
+}
+function getCookiesEnabled() {
+    try {
+        return navigator.cookieEnabled;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Browser / OS / Device parsing from user-agent
+// ---------------------------------------------------------------------------
+/**
+ * Detect the browser name from the user-agent string.
+ */
+function parseBrowserName(ua) {
+    const s = ua || getUserAgent();
+    if (!s)
+        return '';
+    // Order matters — Edge UA contains "Chrome"
+    if (s.includes('Edg/') || s.includes('Edge/'))
+        return 'Edge';
+    if (s.includes('OPR/') || s.includes('Opera'))
+        return 'Opera';
+    if (s.includes('Firefox/'))
+        return 'Firefox';
+    if (s.includes('Chrome/') && s.includes('Safari/'))
+        return 'Chrome';
+    if (s.includes('Safari/') && !s.includes('Chrome/'))
+        return 'Safari';
+    return 'Other';
+}
+/**
+ * Detect the browser version from the user-agent string.
+ */
+function parseBrowserVersion(ua) {
+    const s = ua || getUserAgent();
+    if (!s)
+        return '';
+    const patterns = [
+        [/Edg\/(\d+[\d.]*)/, 1],
+        [/OPR\/(\d+[\d.]*)/, 1],
+        [/Firefox\/(\d+[\d.]*)/, 1],
+        [/Chrome\/(\d+[\d.]*)/, 1],
+        [/Version\/(\d+[\d.]*).*Safari/, 1],
+    ];
+    for (const [re, group] of patterns) {
+        const m = s.match(re);
+        if (m)
+            return m[group];
+    }
+    return '';
+}
+/**
+ * Detect the OS name from the user-agent string.
+ */
+function parseOsName(ua) {
+    const s = ua || getUserAgent();
+    if (!s)
+        return '';
+    if (s.includes('Windows'))
+        return 'Windows';
+    if (s.includes('Mac OS') || s.includes('Macintosh'))
+        return 'macOS';
+    if (s.includes('iPhone') || s.includes('iPad') || s.includes('iPod'))
+        return 'iOS';
+    if (s.includes('Android'))
+        return 'Android';
+    if (s.includes('CrOS'))
+        return 'Chrome OS';
+    if (s.includes('Linux'))
+        return 'Linux';
+    return 'Other';
+}
+/**
+ * Detect the OS version from the user-agent string.
+ */
+function parseOsVersion(ua) {
+    const s = ua || getUserAgent();
+    if (!s)
+        return '';
+    const patterns = [
+        [/Windows NT ([\d.]+)/, 1],
+        [/Mac OS X ([\d_.]+)/, 1],
+        [/iPhone OS ([\d_]+)/, 1],
+        [/iPad.*? OS ([\d_]+)/, 1],
+        [/Android ([\d.]+)/, 1],
+        [/CrOS [^\s]+ ([\d.]+)/, 1],
+    ];
+    for (const [re, group] of patterns) {
+        const m = s.match(re);
+        if (m)
+            return m[group].replace(/_/g, '.');
+    }
+    return '';
+}
+/**
+ * Detect device type from user-agent string.
+ */
+function parseDeviceType(ua) {
+    const s = ua || getUserAgent();
+    if (!s)
+        return 'desktop';
+    if (/Mobi|Android.*Mobile|iPhone|iPod/.test(s))
+        return 'mobile';
+    if (/Tablet|iPad/.test(s))
+        return 'tablet';
+    return 'desktop';
+}
+/**
+ * Extract UTM parameters from the current page URL.
+ * Once captured on the landing page they are cached in sessionStorage
+ * so subsequent page navigations within the same session retain them.
+ */
+function getUtmParams() {
+    const STORAGE_KEY = 'truxl_utm';
+    // Try to return cached UTM from this session first
+    try {
+        const cached = sessionStorage.getItem(STORAGE_KEY);
+        if (cached)
+            return JSON.parse(cached);
+    }
+    catch { /* ignore */ }
+    const empty = {
+        utmSource: '',
+        utmMedium: '',
+        utmCampaign: '',
+        utmTerm: '',
+        utmContent: '',
+    };
+    try {
+        const params = new URLSearchParams(window.location.search);
+        const utm = {
+            utmSource: params.get('utm_source') || '',
+            utmMedium: params.get('utm_medium') || '',
+            utmCampaign: params.get('utm_campaign') || '',
+            utmTerm: params.get('utm_term') || '',
+            utmContent: params.get('utm_content') || '',
+        };
+        // Only cache if at least one UTM param is present
+        const hasAny = Object.values(utm).some((v) => v !== '');
+        if (hasAny) {
+            try {
+                sessionStorage.setItem(STORAGE_KEY, JSON.stringify(utm));
+            }
+            catch { /* ignore */ }
+        }
+        return hasAny ? utm : empty;
+    }
+    catch {
+        return empty;
+    }
+}
+
+/**
+ * Referrer parsing utilities.
+ * Extracts domain, detects search engines, and persists the initial referrer
+ * for attribution tracking across the user's first visit.
+ */
+const SEARCH_ENGINE_DOMAINS = {
+    'google': 'google',
+    'bing.com': 'bing',
+    'yahoo.com': 'yahoo',
+    'duckduckgo.com': 'duckduckgo',
+    'baidu.com': 'baidu',
+    'yandex.com': 'yandex',
+    'yandex.ru': 'yandex',
+};
+const INITIAL_REFERRER_KEY = 'truxl_initial_referrer';
+/**
+ * Extract the hostname from a URL string.
+ * Returns `$direct` if the URL is empty or invalid.
+ */
+function extractDomain(url) {
+    if (!url)
+        return '$direct';
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return '$direct';
+    }
+}
+/**
+ * Detect if a referrer domain is a known search engine.
+ * Returns the search engine name (e.g., 'google', 'bing') or empty string.
+ */
+function parseSearchEngine(referrerDomain) {
+    if (!referrerDomain || referrerDomain === '$direct')
+        return '';
+    const domain = referrerDomain.toLowerCase();
+    // Check exact matches first
+    for (const [pattern, engine] of Object.entries(SEARCH_ENGINE_DOMAINS)) {
+        if (domain === pattern || domain.endsWith('.' + pattern)) {
+            return engine;
+        }
+    }
+    // Google uses country-specific TLDs (google.co.in, google.de, etc.)
+    if (domain.match(/^(www\.)?google\.[a-z.]+$/)) {
+        return 'google';
+    }
+    return '';
+}
+/**
+ * Get the initial referrer for this user.
+ * On the first visit, persists `document.referrer` (or `$direct`) to localStorage.
+ * Returns the stored value on subsequent visits.
+ */
+function getInitialReferrer() {
+    try {
+        let stored = localStorage.getItem(INITIAL_REFERRER_KEY);
+        if (stored === null) {
+            stored = document.referrer || '$direct';
+            localStorage.setItem(INITIAL_REFERRER_KEY, stored);
+        }
+        return stored;
+    }
+    catch {
+        return document.referrer || '$direct';
+    }
+}
+
+/**
+ * High-level event tracking helpers.
+ *
+ * Provides convenience wrappers around `TruxlClient.track()` for common
+ * event types such as custom events and page views. Each helper enriches
+ * the event payload with contextual browser information.
+ */
+/**
+ * Track a custom event.
+ *
+ * @param client      The TruxlClient instance.
+ * @param eventName   A descriptive name for the event (e.g. "button_click",
+ *                    "signup_started").
+ * @param properties  Arbitrary key/value properties to attach to the event.
+ */
+function trackEvent(client, eventName, properties) {
+    const browser = getBrowserInfo();
+    client.track(eventName, {
+        ...properties,
+        $browser_info: {
+            user_agent: browser.userAgent,
+            language: browser.language,
+            screen_width: browser.screenWidth,
+            screen_height: browser.screenHeight,
+            viewport_width: browser.viewportWidth,
+            viewport_height: browser.viewportHeight,
+        },
+        $url: browser.url,
+        $path: browser.path,
+        $referrer: browser.referrer,
+        $title: browser.title,
+        $hostname: browser.hostname,
+    });
+}
+/**
+ * Track a page view event.
+ *
+ * Automatically captures the current URL, path, referrer, page title and
+ * other contextual data.
+ *
+ * @param client      The TruxlClient instance.
+ * @param properties  Optional extra properties to merge into the event.
+ */
+function trackPageView(client, properties) {
+    const browser = getBrowserInfo();
+    client.track('$pageview', {
+        ...properties,
+        $url: browser.url,
+        $path: browser.path,
+        $referrer: browser.referrer,
+        $title: browser.title,
+        $hostname: browser.hostname,
+        $screen_width: browser.screenWidth,
+        $screen_height: browser.screenHeight,
+        $viewport_width: browser.viewportWidth,
+        $viewport_height: browser.viewportHeight,
+        $device_pixel_ratio: browser.devicePixelRatio,
+        $language: browser.language,
+        $timezone: browser.timezone,
+        $online: browser.online,
+    });
+}
+
+/**
+ * Form submission tracking.
+ *
+ * Intercepts native `<form>` submit events via a delegated listener on
+ * `document` and tracks a `$form_submit` event with metadata about the
+ * form and its fields (excluding sensitive inputs such as passwords and
+ * credit card numbers).
+ */
+/** Teardown callback for stopping form tracking. */
+let teardownFn = null;
+/**
+ * Start tracking form submissions. Idempotent -- calling this multiple
+ * times will not register duplicate listeners.
+ *
+ * @param client  The TruxlClient instance to report events to.
+ */
+function startFormTracking(client) {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    // Prevent duplicate listeners
+    if (teardownFn) {
+        return;
+    }
+    const handleSubmit = (event) => {
+        const form = event.target;
+        if (!form || form.tagName.toLowerCase() !== 'form')
+            return;
+        const properties = {
+            $form_id: form.id || undefined,
+            $form_name: form.getAttribute('name') || undefined,
+            $form_action: form.action || undefined,
+            $form_method: (form.method || 'GET').toUpperCase(),
+            $form_fields: collectFieldMetadata(form),
+        };
+        trackEvent(client, '$form_submit', properties);
+    };
+    document.addEventListener('submit', handleSubmit, true);
+    teardownFn = () => {
+        document.removeEventListener('submit', handleSubmit, true);
+    };
+}
+/**
+ * Stop tracking form submissions and remove the event listener.
+ */
+function stopFormTracking() {
+    if (teardownFn) {
+        teardownFn();
+        teardownFn = null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/** Input types whose values must NEVER be captured. */
+const SENSITIVE_TYPES = new Set([
+    'password',
+    'hidden',
+    'file',
+]);
+/** Input names (lowercase) that suggest sensitive content. */
+const SENSITIVE_NAME_PATTERNS$1 = [
+    'password',
+    'passwd',
+    'secret',
+    'token',
+    'credit',
+    'card',
+    'cvv',
+    'cvc',
+    'ssn',
+    'social',
+];
+/**
+ * Iterate over form elements and collect non-sensitive metadata.
+ */
+function collectFieldMetadata(form) {
+    const fields = [];
+    const elements = form.elements;
+    for (let i = 0; i < elements.length; i++) {
+        const el = elements[i];
+        const tag = el.tagName.toLowerCase();
+        if (!['input', 'select', 'textarea'].includes(tag))
+            continue;
+        const type = el.type?.toLowerCase() ?? '';
+        const name = el.name || undefined;
+        const id = el.id || undefined;
+        const isSensitive = isSensitiveField(type, name);
+        const meta = {
+            tag,
+            type: type || undefined,
+            name,
+            id,
+            redacted: isSensitive,
+        };
+        if (!isSensitive) {
+            meta.value = truncateValue(el.value);
+        }
+        fields.push(meta);
+    }
+    return fields;
+}
+/**
+ * Determine whether a field is sensitive based on its type and name.
+ */
+function isSensitiveField(type, name) {
+    if (SENSITIVE_TYPES.has(type))
+        return true;
+    if (name) {
+        const lower = name.toLowerCase();
+        return SENSITIVE_NAME_PATTERNS$1.some((pattern) => lower.includes(pattern));
+    }
+    return false;
+}
+/**
+ * Truncate field values to avoid sending excessively large payloads.
+ */
+function truncateValue(value, maxLength = 512) {
+    if (value.length <= maxLength)
+        return value;
+    return value.slice(0, maxLength) + '...';
+}
+
+/**
+ * Auto-capture module.
+ *
+ * When enabled, automatically tracks based on the resolved AutocaptureConfig:
+ *   - click: Click events on buttons and links
+ *   - dead_click: Clicks that produce no DOM mutation
+ *   - rage_click: Rapid repeated clicks on the same element
+ *   - input: Input field value changes (sensitive fields redacted)
+ *   - scroll: Scroll depth milestones (25%, 50%, 75%, 100%)
+ *   - submit: Form submissions (delegates to form tracking module)
+ *   - pageview: Page view events on URL changes
+ *
+ * Auto-capture is opt-in via `TruxlConfig.autocapture`.
+ */
+/** Keeps track of teardown callbacks so auto-capture can be stopped. */
+let teardownFns = [];
+// ---------------------------------------------------------------------------
+// Sensitive field detection (shared with input tracking)
+// ---------------------------------------------------------------------------
+const SENSITIVE_INPUT_TYPES = new Set(['password', 'hidden', 'file']);
+const SENSITIVE_NAME_PATTERNS = [
+    'password', 'passwd', 'secret', 'token', 'credit', 'card',
+    'cvv', 'cvc', 'ssn', 'social',
+];
+function isSensitiveInput(el) {
+    const type = el.type?.toLowerCase() ?? '';
+    if (SENSITIVE_INPUT_TYPES.has(type))
+        return true;
+    const name = (el.name || el.id || '').toLowerCase();
+    return SENSITIVE_NAME_PATTERNS.some((p) => name.includes(p));
+}
+const RAGE_CLICK_THRESHOLD = 3;
+const RAGE_CLICK_WINDOW_MS = 1000;
+// ---------------------------------------------------------------------------
+// Dead-click detection helpers
+// ---------------------------------------------------------------------------
+const DEAD_CLICK_WAIT_MS = 1000;
+/**
+ * Start auto-capturing interactions. Idempotent -- calling this multiple
+ * times will not register duplicate listeners.
+ */
+function startAutocapture(client, config) {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+    }
+    // Prevent duplicate listeners
+    if (teardownFns.length > 0) {
+        return;
+    }
+    const captureText = config.capture_text_content;
+    // ------------------------------------------------------------------
+    // 1. Click auto-capture (delegation on document)
+    // ------------------------------------------------------------------
+    if (config.click || config.dead_click || config.rage_click) {
+        const recentClicks = [];
+        const handleClick = (event) => {
+            const target = event.target;
+            if (!target)
+                return;
+            const element = findTrackableAncestor(target);
+            // --- Standard click tracking ---
+            if (config.click && element) {
+                const tagName = element.tagName.toLowerCase();
+                const properties = {
+                    $element_tag: tagName,
+                    $element_classes: element.className || undefined,
+                    $element_id: element.id || undefined,
+                };
+                if (captureText) {
+                    properties.$element_text = truncate(element.textContent?.trim() ?? '', 256);
+                }
+                if (tagName === 'a') {
+                    properties.$element_href = element.href;
+                }
+                if (element.dataset.truxlEvent) {
+                    properties.$custom_event_name = element.dataset.truxlEvent;
+                }
+                trackEvent(client, '$autocapture_click', properties);
+            }
+            // --- Rage-click detection ---
+            if (config.rage_click && element) {
+                const now = Date.now();
+                recentClicks.push({ target: element, timestamp: now });
+                // Remove old entries outside the time window
+                while (recentClicks.length > 0 && now - recentClicks[0].timestamp > RAGE_CLICK_WINDOW_MS) {
+                    recentClicks.shift();
+                }
+                const sameTargetClicks = recentClicks.filter((c) => c.target === element);
+                if (sameTargetClicks.length >= RAGE_CLICK_THRESHOLD) {
+                    const tagName = element.tagName.toLowerCase();
+                    trackEvent(client, '$rage_click', {
+                        $element_tag: tagName,
+                        $element_classes: element.className || undefined,
+                        $element_id: element.id || undefined,
+                        $element_text: captureText ? truncate(element.textContent?.trim() ?? '', 256) : undefined,
+                        $click_count: sameTargetClicks.length,
+                    });
+                    // Reset to avoid repeated rage-click events for same burst
+                    recentClicks.length = 0;
+                }
+            }
+            // --- Dead-click detection ---
+            if (config.dead_click) {
+                const clickedElement = element || target;
+                detectDeadClick(client, clickedElement, captureText);
+            }
+        };
+        document.addEventListener('click', handleClick, true);
+        teardownFns.push(() => document.removeEventListener('click', handleClick, true));
+    }
+    // ------------------------------------------------------------------
+    // 2. Input change tracking
+    // ------------------------------------------------------------------
+    if (config.input) {
+        const handleChange = (event) => {
+            const el = event.target;
+            if (!el)
+                return;
+            const tag = el.tagName.toLowerCase();
+            if (!['input', 'select', 'textarea'].includes(tag))
+                return;
+            const sensitive = isSensitiveInput(el);
+            const type = el.type?.toLowerCase() ?? '';
+            const properties = {
+                $element_tag: tag,
+                $element_type: type || undefined,
+                $element_name: el.name || undefined,
+                $element_id: el.id || undefined,
+                $value_redacted: sensitive,
+            };
+            if (!sensitive && captureText) {
+                properties.$element_value = truncate(el.value, 256);
+            }
+            if (!sensitive && !captureText) {
+                // Still capture value length for analytics without exposing content
+                properties.$value_length = el.value.length;
+            }
+            trackEvent(client, '$autocapture_input', properties);
+        };
+        document.addEventListener('change', handleChange, true);
+        teardownFns.push(() => document.removeEventListener('change', handleChange, true));
+    }
+    // ------------------------------------------------------------------
+    // 3. Scroll depth tracking
+    // ------------------------------------------------------------------
+    if (config.scroll) {
+        const milestones = [25, 50, 75, 100];
+        const reachedMilestones = new Set();
+        let scrollPath = window.location.pathname;
+        const handleScroll = () => {
+            // Reset milestones on navigation
+            if (window.location.pathname !== scrollPath) {
+                reachedMilestones.clear();
+                scrollPath = window.location.pathname;
+            }
+            const scrollTop = window.scrollY || document.documentElement.scrollTop;
+            const docHeight = Math.max(document.documentElement.scrollHeight, document.body.scrollHeight);
+            const viewportHeight = window.innerHeight;
+            if (docHeight <= viewportHeight)
+                return; // No scrollable content
+            const scrollPercent = Math.round(((scrollTop + viewportHeight) / docHeight) * 100);
+            for (const milestone of milestones) {
+                if (scrollPercent >= milestone && !reachedMilestones.has(milestone)) {
+                    reachedMilestones.add(milestone);
+                    trackEvent(client, '$autocapture_scroll', {
+                        $scroll_depth: milestone,
+                        $scroll_depth_pixels: scrollTop + viewportHeight,
+                        $document_height: docHeight,
+                        $url: window.location.href,
+                        $path: window.location.pathname,
+                    });
+                }
+            }
+        };
+        // Throttle scroll events
+        let scrollTimeout = null;
+        const throttledScroll = () => {
+            if (scrollTimeout)
+                return;
+            scrollTimeout = setTimeout(() => {
+                scrollTimeout = null;
+                handleScroll();
+            }, 200);
+        };
+        window.addEventListener('scroll', throttledScroll, { passive: true });
+        teardownFns.push(() => window.removeEventListener('scroll', throttledScroll));
+    }
+    // ------------------------------------------------------------------
+    // 4. Form submit tracking (delegates to forms module)
+    // ------------------------------------------------------------------
+    if (config.submit) {
+        startFormTracking(client);
+        teardownFns.push(() => stopFormTracking());
+    }
+    // ------------------------------------------------------------------
+    // 5. Page view on URL change (only if autocapture.pageview is set)
+    // ------------------------------------------------------------------
+    if (config.pageview) {
+        let lastUrl = window.location.href;
+        const checkUrlChange = () => {
+            const currentUrl = window.location.href;
+            if (currentUrl !== lastUrl) {
+                lastUrl = currentUrl;
+                trackPageView(client, buildPageviewProperties(config.pageview));
+            }
+        };
+        // Track initial page view
+        trackPageView(client, buildPageviewProperties(config.pageview));
+        // Monitor pushState / replaceState
+        const originalPushState = history.pushState.bind(history);
+        const originalReplaceState = history.replaceState.bind(history);
+        history.pushState = function (...args) {
+            originalPushState(...args);
+            checkUrlChange();
+        };
+        history.replaceState = function (...args) {
+            originalReplaceState(...args);
+            checkUrlChange();
+        };
+        teardownFns.push(() => {
+            history.pushState = originalPushState;
+            history.replaceState = originalReplaceState;
+        });
+        // Monitor back/forward navigation
+        const handlePopState = () => checkUrlChange();
+        window.addEventListener('popstate', handlePopState);
+        teardownFns.push(() => window.removeEventListener('popstate', handlePopState));
+    }
+}
+/**
+ * Stop auto-capture and remove all registered event listeners.
+ */
+function stopAutocapture() {
+    for (const fn of teardownFns) {
+        fn();
+    }
+    teardownFns = [];
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Build extra properties for pageview events based on the pageview config.
+ */
+function buildPageviewProperties(pageviewMode) {
+    if (pageviewMode === 'path-only') {
+        return { $pageview_mode: 'path-only' };
+    }
+    return undefined;
+}
+/**
+ * Detect dead clicks: clicks that produce no visible DOM mutation within a timeout.
+ * Uses MutationObserver to watch for changes after a click.
+ */
+function detectDeadClick(client, element, captureText) {
+    let mutated = false;
+    const observer = new MutationObserver(() => {
+        mutated = true;
+        observer.disconnect();
+    });
+    observer.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        characterData: true,
+    });
+    setTimeout(() => {
+        observer.disconnect();
+        if (!mutated) {
+            const tagName = element.tagName.toLowerCase();
+            trackEvent(client, '$dead_click', {
+                $element_tag: tagName,
+                $element_classes: element.className || undefined,
+                $element_id: element.id || undefined,
+                $element_text: captureText ? truncate(element.textContent?.trim() ?? '', 256) : undefined,
+            });
+        }
+    }, DEAD_CLICK_WAIT_MS);
+}
+/**
+ * Walk up the DOM tree from `element` to find the nearest `<a>` or
+ * `<button>` ancestor (including the element itself). Returns `null` when
+ * the target is not a trackable element.
+ */
+function findTrackableAncestor(element) {
+    let current = element;
+    const maxDepth = 5;
+    for (let i = 0; i < maxDepth && current; i++) {
+        const tag = current.tagName.toLowerCase();
+        if (tag === 'a' ||
+            tag === 'button' ||
+            current.getAttribute('role') === 'button') {
+            return current;
+        }
+        current = current.parentElement;
+    }
+    return null;
+}
+/**
+ * Truncate a string to `maxLength`, appending "..." when truncated.
+ */
+function truncate(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return value.slice(0, maxLength) + '...';
+}
+
+const SDK_VERSION = '0.1.0';
+class TruxlClient {
+    constructor(config) {
+        this.distinctId = null;
+        // ------------------------------------------------------------------
+        // Standalone pageview tracking (when track_pageview=true but autocapture.pageview is off)
+        // ------------------------------------------------------------------
+        this.pageviewTeardownFns = [];
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.deviceId = this.getOrCreateDeviceId();
+        this.distinctId = this.loadDistinctId();
+        this.initialReferrer = getInitialReferrer();
+        this.transport = this.config.transport === 'websocket'
+            ? new WebSocketTransport({ config: this.config })
+            : new HttpTransport({ config: this.config });
+        this.queue = new EventQueue(this.config, this.transport);
+        // Start autocapture if enabled
+        const autocaptureConfig = resolveAutocaptureConfig(this.config.autocapture);
+        if (autocaptureConfig) {
+            startAutocapture(this, autocaptureConfig);
+        }
+        // Track initial pageview if track_pageview is enabled (and autocapture.pageview isn't already handling it)
+        if (this.config.track_pageview && !(autocaptureConfig && autocaptureConfig.pageview)) {
+            this.startPageviewTracking();
+        }
+        if (this.config.debug) {
+            console.log('[Truxl] Initialized with config:', this.config);
+        }
+    }
+    track(eventName, properties) {
+        const referrer = getReferrer();
+        const referrerDomain = extractDomain(referrer);
+        const mergedProperties = { ...(properties || {}) };
+        const utm = getUtmParams();
+        const event = {
+            eventName: eventName,
+            distinctId: this.distinctId || this.deviceId,
+            deviceId: this.deviceId,
+            timestamp: Date.now(),
+            properties: mergedProperties,
+            sessionId: this.getSessionId(),
+            sdk: 'web',
+            sdkVersion: SDK_VERSION,
+            screenWidth: String(getScreenWidth()),
+            screenHeight: String(getScreenHeight()),
+            browser: parseBrowserName(),
+            browserVersion: parseBrowserVersion(),
+            os: parseOsName(),
+            osVersion: parseOsVersion(),
+            deviceType: parseDeviceType(),
+            referrer: referrer,
+            userTimezone: getTimezone(),
+            initialReferrer: this.initialReferrer,
+            searchEngine: parseSearchEngine(referrerDomain),
+            utmSource: utm.utmSource,
+            utmMedium: utm.utmMedium,
+            utmCampaign: utm.utmCampaign,
+            utmTerm: utm.utmTerm,
+            utmContent: utm.utmContent,
+        };
+        this.queue.enqueue(event);
+        if (this.config.debug) {
+            console.log('[Truxl] Track:', eventName, properties);
+        }
+    }
+    identify(distinctId, userProperties) {
+        this.distinctId = distinctId;
+        try {
+            localStorage.setItem('truxl_distinct_id', distinctId);
+        }
+        catch { }
+        if (userProperties) {
+            this.track('$identify', { $set: userProperties });
+        }
+        if (this.config.debug) {
+            console.log('[Truxl] Identify:', distinctId, userProperties);
+        }
+    }
+    reset() {
+        this.distinctId = null;
+        try {
+            localStorage.removeItem('truxl_distinct_id');
+        }
+        catch { }
+    }
+    flush() {
+        this.queue.flush();
+    }
+    destroy() {
+        stopAutocapture();
+        this.stopPageviewTracking();
+        this.queue.destroy();
+    }
+    startPageviewTracking() {
+        if (typeof window === 'undefined')
+            return;
+        let lastUrl = window.location.href;
+        const checkUrlChange = () => {
+            const currentUrl = window.location.href;
+            if (currentUrl !== lastUrl) {
+                lastUrl = currentUrl;
+                trackPageView(this);
+            }
+        };
+        // Track initial page view
+        trackPageView(this);
+        // Monitor pushState / replaceState
+        const originalPushState = history.pushState.bind(history);
+        const originalReplaceState = history.replaceState.bind(history);
+        history.pushState = function (...args) {
+            originalPushState(...args);
+            checkUrlChange();
+        };
+        history.replaceState = function (...args) {
+            originalReplaceState(...args);
+            checkUrlChange();
+        };
+        this.pageviewTeardownFns.push(() => {
+            history.pushState = originalPushState;
+            history.replaceState = originalReplaceState;
+        });
+        const handlePopState = () => checkUrlChange();
+        window.addEventListener('popstate', handlePopState);
+        this.pageviewTeardownFns.push(() => window.removeEventListener('popstate', handlePopState));
+    }
+    stopPageviewTracking() {
+        for (const fn of this.pageviewTeardownFns) {
+            fn();
+        }
+        this.pageviewTeardownFns = [];
+    }
+    loadDistinctId() {
+        try {
+            return localStorage.getItem('truxl_distinct_id');
+        }
+        catch {
+            return null;
+        }
+    }
+    getOrCreateDeviceId() {
+        const key = 'truxl_device_id';
+        try {
+            let id = localStorage.getItem(key);
+            if (!id) {
+                id = crypto.randomUUID();
+                localStorage.setItem(key, id);
+            }
+            return id;
+        }
+        catch {
+            return crypto.randomUUID();
+        }
+    }
+    getSessionId() {
+        const key = 'truxl_session_id';
+        try {
+            let id = sessionStorage.getItem(key);
+            if (!id) {
+                id = crypto.randomUUID();
+                sessionStorage.setItem(key, id);
+            }
+            return id;
+        }
+        catch {
+            return crypto.randomUUID();
+        }
+    }
+}
+
+/**
+ * Beacon transport for page unload scenarios.
+ *
+ * Uses `navigator.sendBeacon()` which is designed to reliably deliver small
+ * payloads even when the page is being closed. This is the preferred
+ * transport for `beforeunload` / `visibilitychange` events where a normal
+ * `fetch()` would likely be cancelled by the browser.
+ *
+ * Falls back to a synchronous `XMLHttpRequest` (keepalive-style) when
+ * `sendBeacon` is not available.
+ */
+class BeaconTransport {
+    constructor(options) {
+        this.config = options.config;
+    }
+    /**
+     * Send a payload via `navigator.sendBeacon`. Returns `true` when the
+     * browser accepted the request for delivery (note: this does NOT
+     * guarantee the server received it).
+     *
+     * Because `sendBeacon` is fire-and-forget, HMAC signing is performed
+     * synchronously using the pre-computed signature passed in via headers
+     * encoded as a Blob.
+     */
+    async send(payload) {
+        const body = JSON.stringify(payload);
+        const signature = await signPayload(body, this.config.clientSecret);
+        const url = `${this.config.apiEndpoint}/v1/batch`;
+        if (this.isBeaconAvailable()) {
+            return this.sendViaBeacon(url, body, signature);
+        }
+        return this.sendViaXHR(url, body, signature);
+    }
+    /**
+     * Synchronous variant that can be called from `beforeunload` handlers
+     * where async work is unreliable. Requires the caller to pre-compute
+     * the HMAC signature.
+     */
+    sendSync(payload, precomputedSignature) {
+        const body = JSON.stringify(payload);
+        const url = `${this.config.apiEndpoint}/v1/batch`;
+        if (this.isBeaconAvailable()) {
+            return this.sendViaBeacon(url, body, precomputedSignature);
+        }
+        return this.sendViaXHR(url, body, precomputedSignature);
+    }
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+    isBeaconAvailable() {
+        return (typeof navigator !== 'undefined' &&
+            typeof navigator.sendBeacon === 'function');
+    }
+    sendViaBeacon(url, body, signature) {
+        // sendBeacon does not support custom headers, so we encode the
+        // metadata as query parameters and send a JSON blob.
+        const beaconUrl = `${url}?token=${encodeURIComponent(this.config.projectToken)}&sig=${encodeURIComponent(signature)}`;
+        const blob = new Blob([body], { type: 'application/json' });
+        return navigator.sendBeacon(beaconUrl, blob);
+    }
+    sendViaXHR(url, body, signature) {
+        try {
+            const xhr = new XMLHttpRequest();
+            // Use synchronous XHR as last resort during page unload
+            xhr.open('POST', url, false);
+            xhr.setRequestHeader('Content-Type', 'application/json');
+            xhr.setRequestHeader('X-Project-Token', this.config.projectToken);
+            xhr.setRequestHeader('X-Signature', signature);
+            xhr.send(body);
+            return xhr.status >= 200 && xhr.status < 300;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+export { BeaconTransport, HttpTransport, TruxlClient, WebSocketTransport };
+//# sourceMappingURL=truxl.esm.js.map