@v-tilt/browser 1.6.0 → 1.7.2

package/lib/vtilt.js

@@ -1,1188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VTilt = void 0;
-exports.init_as_module = init_as_module;
-exports.init_from_snippet = init_from_snippet;
-const constants_1 = require("./constants");
-const config_1 = require("./config");
-const session_1 = require("./session");
-const user_manager_1 = require("./user-manager");
-const web_vitals_1 = require("./web-vitals");
-const history_autocapture_1 = require("./extensions/history-autocapture");
-const replay_1 = require("./extensions/replay");
-const chat_wrapper_1 = require("./extensions/chat/chat-wrapper");
-const request_1 = require("./request");
-const request_queue_1 = require("./request-queue");
-const retry_queue_1 = require("./retry-queue");
-const rate_limiter_1 = require("./rate-limiter");
-const utils_1 = require("./utils");
-const event_utils_1 = require("./utils/event-utils");
-const globals_1 = require("./utils/globals");
-/*
-STYLE GUIDE:
-
-Naming conventions:
-- snake_case: Config options and public API methods (e.g., capture_pageview, get_distinct_id)
-- camelCase: Internal variables and class properties (e.g., sessionManager, requestQueue)
-- _snake_case: Private methods that can be mangled/minified (e.g., _init, _dom_loaded)
-- __snake_case: Internal but not minified, signals internal use (e.g., __loaded, __request_queue)
-- UPPER_CASE: Constants and globals (e.g., PRIMARY_INSTANCE_NAME, ENQUEUE_REQUESTS)
-
-Use TypeScript accessibility modifiers (private/protected) for non-public members.
-*/
-// Helper to check if value is an array
-const isArray = Array.isArray;
-class VTilt {
-    constructor(config = {}) {
-        // SDK version from constants (single source of truth)
-        this.version = constants_1.SDK_VERSION;
-        this.__loaded = false; // Matches snippet's window.vt.__loaded check
-        this._initial_pageview_captured = false;
-        this._visibility_state_listener = null;
-        this.__request_queue = []; // Legacy queue for DOM loaded handler (pre-init)
-        this._has_warned_about_config = false; // Track if we've already warned about missing config
-        this._set_once_properties_sent = false; // Track if $set_once with initial props has been sent (only send once per page load)
-        this._remoteConfig = null; // Cached remote config from /decide
-        this.configManager = new config_1.ConfigManager(config);
-        const fullConfig = this.configManager.getConfig();
-        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", fullConfig.cross_subdomain_cookie);
-        // Default to localStorage+cookie for better SSR support (following PostHog)
-        // Critical properties (anonymous_id, device_id, etc.) are stored in cookies
-        // This ensures identity persists across page navigations in traditional SSR websites
-        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage+cookie", fullConfig.cross_subdomain_cookie);
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
-        // Initialize rate limiter to prevent flooding
-        // Default: 10 events/second with burst of 100
-        this.rateLimiter = new rate_limiter_1.RateLimiter({
-            eventsPerSecond: 10,
-            eventsBurstLimit: 100,
-            captureWarning: (message) => {
-                // Send rate limit warning event (bypasses rate limiting)
-                this._capture_internal(rate_limiter_1.RATE_LIMIT_WARNING_EVENT, {
-                    $$client_ingestion_warning_message: message,
-                });
-            },
-        });
-        // Initialize retry queue for failed requests
-        // Retries with exponential backoff: 3s, 6s, 12s... up to 30 minutes
-        this.retryQueue = new retry_queue_1.RetryQueue({
-            sendRequest: (req) => this._send_http_request(req),
-            sendBeacon: (req) => this._send_beacon_request(req),
-        });
-        // Initialize request queue for event batching
-        // Events are batched and sent every 3 seconds (configurable)
-        this.requestQueue = new request_queue_1.RequestQueue((req) => this._send_batched_request(req), { flush_interval_ms: 3000 });
-    }
-    /**
-     * Initializes a new instance of the VTilt tracking object.
-     *
-     * @remarks
-     * All new instances are added to the main vt object as sub properties (such as
-     * `vt.library_name`) and also returned by this function.
-     *
-     * @example
-     * ```js
-     * // basic initialization
-     * vt.init('<project_id>', {
-     *     api_host: '<client_api_host>'
-     * })
-     * ```
-     *
-     * @example
-     * ```js
-     * // multiple instances
-     * vt.init('<project_id>', {}, 'project1')
-     * vt.init('<project_id>', {}, 'project2')
-     * ```
-     *
-     * @public
-     *
-     * @param projectId - Your VTilt project ID
-     * @param config - A dictionary of config options to override
-     * @param name - The name for the new VTilt instance that you want created
-     *
-     * @returns The newly initialized VTilt instance
-     */
-    init(projectId, config, name) {
-        var _a;
-        if (!name || name === PRIMARY_INSTANCE_NAME) {
-            // This means we are initializing the primary instance (i.e. this)
-            return this._init(projectId, config, name);
-        }
-        else {
-            const namedVTilt = (_a = instances[name]) !== null && _a !== void 0 ? _a : new VTilt();
-            namedVTilt._init(projectId, config, name);
-            instances[name] = namedVTilt;
-            // Add as a property to the primary instance (this isn't type-safe but its how it was always done)
-            instances[PRIMARY_INSTANCE_NAME][name] = namedVTilt;
-            return namedVTilt;
-        }
-    }
-    /**
-     * Handles the actual initialization logic for a VTilt instance.
-     * This internal method should only be called by `init()`.
-     */
-    _init(projectId, config = {}, name) {
-        // Guard: prevent re-initialization (matches snippet's __loaded check)
-        if (this.__loaded) {
-            console.warn("vTilt: You have already initialized vTilt! Re-initializing is a no-op");
-            return this;
-        }
-        // Update config with projectId, token, and name
-        this.updateConfig({
-            ...config,
-            projectId: projectId || config.projectId,
-            name: name,
-        });
-        this.__loaded = true;
-        // Load cached remote config (sync) and apply to config
-        // Fresh fetch happens async in background for next session
-        this._loadRemoteConfig();
-        // Set initial person info: stores referrer and URL on first visit
-        const fullConfig = this.configManager.getConfig();
-        this.userManager.set_initial_person_info(fullConfig.mask_personal_data_properties, fullConfig.custom_personal_data_properties);
-        // Initialize history autocapture
-        this.historyAutocapture = new history_autocapture_1.HistoryAutocapture(this);
-        this.historyAutocapture.startIfEnabled();
-        // Initialize session recording if enabled
-        this._initSessionRecording();
-        // Initialize chat widget
-        this._initChat();
-        // Set up page unload handler to flush queued events
-        this._setup_unload_handler();
-        // Enable the request queue for batched sending (PostHog pattern)
-        this._start_queue_if_opted_in();
-        // Capture initial pageview (with visibility check)
-        // Only if capture_pageview is enabled (default: true)
-        if (fullConfig.capture_pageview !== false) {
-            this._capture_initial_pageview();
-        }
-        return this;
-    }
-    /**
-     * Start the request queue if user hasn't opted out
-     * Following PostHog's pattern - called from both _init() and _dom_loaded()
-     * Safe to call multiple times as enable() is idempotent
-     */
-    _start_queue_if_opted_in() {
-        // TODO: Add opt-out check when consent management is implemented
-        // if (!this.is_capturing()) return;
-        // Enable batched sending
-        this.requestQueue.enable();
-    }
-    /**
-     * Set up handler to flush event queue on page unload
-     * Uses both beforeunload and pagehide for maximum compatibility
-     */
-    _setup_unload_handler() {
-        if (!globals_1.window) {
-            return;
-        }
-        const unloadHandler = () => {
-            // Flush all queued events using sendBeacon for reliable delivery
-            this.requestQueue.unload();
-            // Also flush any pending retries
-            this.retryQueue.unload();
-        };
-        // beforeunload is more reliable but pagehide works better on mobile
-        (0, utils_1.addEventListener)(globals_1.window, "beforeunload", unloadHandler);
-        (0, utils_1.addEventListener)(globals_1.window, "pagehide", unloadHandler);
-    }
-    /**
-     * Load remote config from cache and fetch fresh in background.
-     * Uses sessionStorage for per-session caching.
-     * Local config always overrides remote config.
-     */
-    _loadRemoteConfig() {
-        const config = this.configManager.getConfig();
-        if (!config.projectId)
-            return;
-        // Try to load cached config (sync)
-        try {
-            const cached = sessionStorage.getItem(`${constants_1.REMOTE_CONFIG_KEY}_${config.projectId}`);
-            if (cached) {
-                this._remoteConfig = JSON.parse(cached);
-                this._applyRemoteConfig(this._remoteConfig);
-            }
-        }
-        catch (_a) {
-            // sessionStorage not available or parse error
-        }
-        // Fetch fresh config async (for next page load / feature updates)
-        this._fetchRemoteConfig();
-    }
-    /**
-     * Fetch remote config from /decide endpoint.
-     * Caches response in sessionStorage.
-     */
-    _fetchRemoteConfig() {
-        const config = this.configManager.getConfig();
-        if (!config.projectId || !config.api_host)
-            return;
-        const url = `${config.api_host}/api/projects/${config.projectId}/decide`;
-        // Use fetch with timeout for non-blocking request
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3000);
-        (globals_1.fetch || fetch)(url, {
-            method: "GET",
-            signal: controller.signal,
-            headers: { Accept: "application/json" },
-        })
-            .then((res) => res.json())
-            .then((data) => {
-            clearTimeout(timeout);
-            this._remoteConfig = data;
-            // Cache for next page load
-            try {
-                sessionStorage.setItem(`${constants_1.REMOTE_CONFIG_KEY}_${config.projectId}`, JSON.stringify(data));
-            }
-            catch (_a) {
-                // sessionStorage quota exceeded or not available
-            }
-            // Apply to config (for features not yet initialized)
-            this._applyRemoteConfig(data);
-        })
-            .catch(() => {
-            clearTimeout(timeout);
-            // Silently fail - use cached or default config
-        });
-    }
-    /**
-     * Apply remote config to current config.
-     * Local config takes precedence over remote.
-     */
-    _applyRemoteConfig(remote) {
-        var _a;
-        const config = this.configManager.getConfig();
-        const updates = {};
-        // Session Recording (only if not explicitly set locally)
-        if (remote.sessionRecording && config.session_recording === undefined) {
-            updates.session_recording = {
-                enabled: remote.sessionRecording.enabled,
-                sampleRate: remote.sessionRecording.sampleRate,
-                minimumDurationMs: remote.sessionRecording.minimumDurationMs,
-                maskAllInputs: remote.sessionRecording.maskAllInputs,
-                captureConsole: remote.sessionRecording.captureConsole,
-                captureCanvas: remote.sessionRecording.captureCanvas,
-            };
-        }
-        // Analytics
-        if (remote.analytics) {
-            if (remote.analytics.capturePageview !== undefined &&
-                config.capture_pageview === undefined) {
-                updates.capture_pageview = remote.analytics.capturePageview;
-            }
-            if (remote.analytics.capturePageleave !== undefined &&
-                config.capture_pageleave === undefined) {
-                updates.capture_pageleave = remote.analytics.capturePageleave
-                    ? true
-                    : false;
-            }
-            if (remote.analytics.capturePerformance !== undefined &&
-                config.capture_performance === undefined) {
-                updates.capture_performance = remote.analytics.capturePerformance;
-            }
-            if (remote.analytics.autocapture !== undefined &&
-                config.autocapture === undefined) {
-                updates.autocapture = remote.analytics.autocapture;
-            }
-        }
-        // Privacy
-        if (((_a = remote.privacy) === null || _a === void 0 ? void 0 : _a.respectDnt) !== undefined &&
-            config.respect_dnt === undefined) {
-            updates.respect_dnt = remote.privacy.respectDnt;
-        }
-        // Chat widget position/color (handled by ChatWrapper separately)
-        // Apply updates
-        if (Object.keys(updates).length > 0) {
-            this.updateConfig(updates);
-        }
-    }
-    /**
-     * Returns a string representation of the instance name
-     * Used for debugging and logging
-     *
-     * @internal
-     */
-    toString() {
-        var _a;
-        const config = this.configManager.getConfig();
-        let name = (_a = config.name) !== null && _a !== void 0 ? _a : PRIMARY_INSTANCE_NAME;
-        if (name !== PRIMARY_INSTANCE_NAME) {
-            name = PRIMARY_INSTANCE_NAME + "." + name;
-        }
-        return name;
-    }
-    /**
-     * Get current domain from location
-     * Returns full URL format for consistency with dashboard
-     */
-    getCurrentDomain() {
-        if (!globals_1.location) {
-            return "";
-        }
-        const protocol = globals_1.location.protocol;
-        const hostname = globals_1.location.hostname;
-        const port = globals_1.location.port;
-        const portSuffix = port ? `:${port}` : "";
-        return `${protocol}//${hostname}${portSuffix}`;
-    }
-    /**
-     * Check if tracking is properly configured
-     * Returns true if projectId and token are present, false otherwise
-     * Logs a warning only once per instance if not configured
-     */
-    _is_configured() {
-        const config = this.configManager.getConfig();
-        if (config.projectId && config.token) {
-            return true;
-        }
-        // Only warn once to avoid console spam
-        if (!this._has_warned_about_config) {
-            console.warn("VTilt: projectId and token are required for tracking. " +
-                "Events will be skipped until init() or updateConfig() is called with these fields.");
-            this._has_warned_about_config = true;
-        }
-        return false;
-    }
-    /**
-     * Build the tracking URL with token in query parameters
-     */
-    buildUrl() {
-        const config = this.configManager.getConfig();
-        const { proxyUrl, proxy, api_host, token } = config;
-        // Use proxy endpoint to handle backend authentication
-        if (proxyUrl) {
-            // Use the full proxy URL as provided
-            return proxyUrl;
-        }
-        else if (proxy) {
-            // Construct the proxy URL from the proxy domain with token
-            return `${proxy}/api/tracking?token=${token}`;
-        }
-        else if (api_host) {
-            const cleanHost = api_host.replace(/\/+$/gm, "");
-            return `${cleanHost}/api/tracking?token=${token}`;
-        }
-        else {
-            // Use relative path to our tracking proxy endpoint
-            return `/api/tracking?token=${token}`;
-        }
-    }
-    /**
-     * Send HTTP request
-     * This is the central entry point for all tracking requests
-     * Events are batched and sent every 3 seconds for better performance
-     */
-    sendRequest(url, event, shouldEnqueue) {
-        // Validate configuration (only warns once per instance)
-        // This is the single place where validation happens for all sending methods
-        if (!this._is_configured()) {
-            return;
-        }
-        // Check if we should queue requests (for older browsers before DOM is loaded)
-        if (shouldEnqueue && typeof globals_1.window !== "undefined") {
-            // ENQUEUE_REQUESTS is defined in vtilt.ts as a module-level variable
-            const ENQUEUE_REQUESTS = globals_1.window.__VTILT_ENQUEUE_REQUESTS;
-            if (ENQUEUE_REQUESTS) {
-                this.__request_queue.push({ url, event });
-                return;
-            }
-        }
-        // Enqueue event for batched sending
-        this.requestQueue.enqueue({ url, event });
-    }
-    /**
-     * Send a batched request with multiple events
-     * Called by RequestQueue when flushing
-     * Uses RetryQueue for automatic retry on failure
-     */
-    _send_batched_request(req) {
-        const { transport } = req;
-        // Use sendBeacon for reliable delivery on page unload
-        if (transport === "sendBeacon") {
-            this._send_beacon_request(req);
-            return;
-        }
-        // Use retry queue for normal requests (handles failures automatically)
-        this.retryQueue.retriableRequest(req);
-    }
-    /**
-     * Send HTTP request and return status code
-     * Uses GZip compression for payloads > 1KB
-     * Used by RetryQueue for retryable requests
-     */
-    _send_http_request(req) {
-        return new Promise((resolve) => {
-            const { url, events } = req;
-            // Prepare payload (single event or batch)
-            const payload = events.length === 1 ? events[0] : { events };
-            // Determine compression
-            const compression = this.configManager.getConfig().disable_compression
-                ? request_1.Compression.None
-                : request_1.Compression.GZipJS;
-            (0, request_1.request)({
-                url,
-                data: payload,
-                method: "POST",
-                transport: "XHR",
-                compression,
-                callback: (response) => {
-                    resolve({ statusCode: response.statusCode });
-                },
-            });
-        });
-    }
-    /**
-     * Send request using sendBeacon for reliable delivery on page unload
-     * Uses GZip compression for payloads > 1KB
-     */
-    _send_beacon_request(req) {
-        const { url, events } = req;
-        // Prepare payload (single event or batch)
-        const payload = events.length === 1 ? events[0] : { events };
-        // Determine compression
-        const compression = this.configManager.getConfig().disable_compression
-            ? request_1.Compression.None
-            : request_1.Compression.GZipJS;
-        (0, request_1.request)({
-            url,
-            data: payload,
-            method: "POST",
-            transport: "sendBeacon",
-            compression,
-        });
-    }
-    /**
-     * Send a queued request (called after DOM is loaded)
-     */
-    _send_retriable_request(item) {
-        this.sendRequest(item.url, item.event, false);
-    }
-    /**
-     * Capture an event
-     * Automatically adds common properties to all events
-     * ($current_url, $host, $pathname, $referrer, $referring_domain, $browser, $os, $device, $timezone, etc.)
-     * Only properties in EVENT_TO_PERSON_PROPERTIES are copied to person properties
-     * Also adds title property for $pageview events only
-     *
-     * @param name - Event name
-     * @param payload - Event payload
-     * @param options - Optional capture options
-     */
-    capture(name, payload, options) {
-        this.sessionManager.setSessionId();
-        // Only send events in browser environment (not SSR)
-        if (!globals_1.navigator || !globals_1.navigator.userAgent) {
-            return;
-        }
-        if (!(0, utils_1.isValidUserAgent)(globals_1.navigator.userAgent)) {
-            return;
-        }
-        // Check rate limiting (unless explicitly skipped)
-        if (!(options === null || options === void 0 ? void 0 : options.skip_client_rate_limiting) &&
-            !this.rateLimiter.shouldAllowEvent()) {
-            // Event is rate limited - drop it silently
-            return;
-        }
-        const url = this.buildUrl();
-        // Add properties to all events
-        // This includes: $current_url, $host, $pathname, $referrer, $referring_domain, $browser, $os, $device, $timezone, etc.
-        // (Only properties in EVENT_TO_PERSON_PROPERTIES are copied to person properties)
-        const eventProperties = (0, event_utils_1.getEventProperties)();
-        // Get person properties (includes $device_id and other user properties)
-        // These are automatically included in all events
-        const personProperties = this.userManager.getUserProperties();
-        // Get initial props: $initial_* properties from stored initial person info
-        const initialProps = this.userManager.get_initial_props();
-        // Get session and window IDs
-        // Both methods ensure IDs always exist (generate if needed)
-        const session_id = this.sessionManager.getSessionId();
-        const window_id = this.sessionManager.getWindowId();
-        // Always include anonymous_id in properties for identity linking
-        // This allows linking events with different distinct_ids that share the same anonymous_id
-        // This is especially important for handling race conditions when $identify events arrive
-        const anonymousId = this.userManager.getAnonymousId();
-        // Build $set_once from initial props (only on first event per page load)
-        // This optimization follows PostHog's pattern: initial props only need to be sent once
-        // since $set_once preserves first values. Sending them on every event would be redundant
-        // and cause unnecessary server processing for identity creation/updates.
-        const setOnce = {};
-        // Only include initial props if we haven't sent them yet this page load
-        if (!this._set_once_properties_sent &&
-            Object.keys(initialProps).length > 0) {
-            Object.assign(setOnce, initialProps);
-        }
-        // Always merge with user-provided $set_once if present
-        if (payload.$set_once) {
-            Object.assign(setOnce, payload.$set_once);
-        }
-        const enrichedPayload = {
-            ...eventProperties, // Base properties for all events
-            ...personProperties, // Person properties (includes $device_id)
-            $session_id: session_id, // Session ID in properties
-            $window_id: window_id, // Window ID in properties
-            // Always include $anon_distinct_id for identity linking (even for identified users)
-            // This allows the server to merge identities proactively when events arrive out of order
-            ...(anonymousId ? { $anon_distinct_id: anonymousId } : {}),
-            // Add $set_once with initial props (only if there are properties to set)
-            ...(Object.keys(setOnce).length > 0 ? { $set_once: setOnce } : {}),
-            // Merge user-provided $set if present
-            ...(payload.$set ? { $set: payload.$set } : {}),
-            ...payload, // User-provided payload (can override base and person properties)
-        };
-        // Mark that $set_once with initial props has been sent (only do this once per page load)
-        if (!this._set_once_properties_sent &&
-            Object.keys(initialProps).length > 0) {
-            this._set_once_properties_sent = true;
-        }
-        // Add title only to $pageview events
-        if (name === "$pageview" && globals_1.document) {
-            enrichedPayload.title = globals_1.document.title;
-        }
-        const config = this.configManager.getConfig();
-        let processedPayload;
-        if (config.stringifyPayload !== false) {
-            processedPayload = Object.assign({}, enrichedPayload, config.globalAttributes);
-            processedPayload = JSON.stringify(processedPayload);
-            if (!(0, utils_1.isValidPayload)(processedPayload)) {
-                return;
-            }
-        }
-        else {
-            processedPayload = Object.assign({}, enrichedPayload, config.globalAttributes);
-            const payloadStr = JSON.stringify(processedPayload);
-            if (!(0, utils_1.isValidPayload)(payloadStr)) {
-                return;
-            }
-        }
-        // Use current distinct_id (or anonymous_id) for event's distinct_id
-        // For $identify events, use anonymous_id as the event's distinct_id (identifying FROM anonymous TO new ID)
-        // New distinct_id should be in payload properties (e.g., for $identify events)
-        let distinct_id;
-        if (name === "$identify") {
-            // For $identify events, always use anonymous_id as the event's distinct_id
-            // The new distinct_id is in the payload
-            distinct_id = this.userManager.getAnonymousId();
-        }
-        else {
-            // For other events, use current distinct_id or fall back to anonymous_id
-            distinct_id =
-                this.userManager.getDistinctId() || this.userManager.getAnonymousId();
-        }
-        const trackingEvent = {
-            timestamp: new Date().toISOString(),
-            event: name,
-            project_id: config.projectId || "",
-            payload: processedPayload,
-            distinct_id: distinct_id,
-            // Always include anonymous_id in the event for identity linking
-            // This allows the server to merge identities proactively
-            anonymous_id: anonymousId,
-        };
-        this.sendRequest(url, trackingEvent, true);
-    }
-    /**
-     * Internal capture method that bypasses rate limiting
-     * Used for system events like rate limit warnings
-     */
-    _capture_internal(name, payload) {
-        this.capture(name, payload, { skip_client_rate_limiting: true });
-    }
-    /**
-     * Track a custom event (alias for capture)
-     */
-    trackEvent(name, payload = {}) {
-        this.capture(name, payload);
-    }
-    /**
-     * Identify a user with property operations
-     * Sends $identify event when transitioning from anonymous to identified
-     * Event's distinct_id is the previous/anonymous ID, new distinct_id is in payload
-     *
-     * @example
-     * ```js
-     * // Basic identify with properties
-     * vTilt.identify('user_123',
-     *   { name: 'John Doe', email: 'john@example.com' },  // $set properties
-     *   { first_login: new Date().toISOString() }         // $set_once properties
-     * )
-     * ```
-     *
-     * @example
-     * ```js
-     * // If no $set is provided, all properties are treated as $set
-     * vTilt.identify('user_123', { name: 'John Doe', email: 'john@example.com' })
-     * ```
-     */
-    identify(newDistinctId, userPropertiesToSet, userPropertiesToSetOnce) {
-        // Validation: Convert number to string
-        if (typeof newDistinctId === "number") {
-            newDistinctId = String(newDistinctId);
-            console.warn("The first argument to vTilt.identify was a number, but it should be a string. It has been converted to a string.");
-        }
-        // Validation: Check if distinct_id is provided
-        if (!newDistinctId) {
-            console.error("Unique user id has not been set in vTilt.identify");
-            return;
-        }
-        // Validation: Check for hardcoded strings
-        if (this.userManager.isDistinctIdStringLikePublic(newDistinctId)) {
-            console.error(`The string "${newDistinctId}" was set in vTilt.identify which indicates an error. This ID should be unique to the user and not a hardcoded string.`);
-            return;
-        }
-        // Validation: Check for cookieless sentinel value
-        if (newDistinctId === "COOKIELESS_SENTINEL_VALUE") {
-            console.error(`The string "${newDistinctId}" was set in vTilt.identify which indicates an error. This ID is only used as a sentinel value.`);
-            return;
-        }
-        const previousDistinctId = this.userManager.getDistinctId();
-        const anonymousId = this.userManager.getAnonymousId();
-        const deviceId = this.userManager.getDeviceId();
-        const isKnownAnonymous = this.userManager.getUserState() === "anonymous";
-        // Handle device ID if not already set
-        if (!deviceId) {
-            const device_id = previousDistinctId || anonymousId;
-            this.userManager.ensureDeviceId(device_id);
-        }
-        // Send $identify event when distinct_id is changing AND user was anonymous
-        // Event's distinct_id is the previous/anonymous ID, new distinct_id goes in payload
-        if (newDistinctId !== previousDistinctId && isKnownAnonymous) {
-            // Update user state and properties BEFORE sending event
-            // (But don't update distinct_id yet - sendEvent needs to use previous ID)
-            this.userManager.setUserState("identified");
-            this.userManager.updateUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
-            // Send $identify event with previous/anonymous ID as event's distinct_id
-            // New distinct_id and properties go in payload
-            this.capture("$identify", {
-                distinct_id: newDistinctId, // New distinct_id in payload
-                $anon_distinct_id: anonymousId, // Previous ID in payload
-                $set: userPropertiesToSet || {},
-                $set_once: userPropertiesToSetOnce || {},
-            });
-            // Now update distinct_id after sending the event
-            this.userManager.setDistinctId(newDistinctId);
-        }
-        else if (userPropertiesToSet || userPropertiesToSetOnce) {
-            // If distinct_id is not changing but we have properties to set
-            // Update user state if not already identified
-            if (isKnownAnonymous) {
-                this.userManager.setUserState("identified");
-            }
-            // Update properties
-            this.userManager.updateUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
-            // Send $set event to notify server of property updates
-            this.capture("$set", {
-                $set: userPropertiesToSet || {},
-                $set_once: userPropertiesToSetOnce || {},
-            });
-        }
-        else if (newDistinctId !== previousDistinctId) {
-            // If distinct_id is changing but user was already identified, just update the distinct_id
-            this.userManager.setUserState("identified");
-            this.userManager.setDistinctId(newDistinctId);
-        }
-    }
-    /**
-     * Set user properties
-     * Sets properties on the person profile associated with the current distinct_id
-     *
-     * @example
-     * ```js
-     * // Set properties that can be updated
-     * vTilt.setUserProperties({ name: 'John Doe', email: 'john@example.com' })
-     * ```
-     *
-     * @example
-     * ```js
-     * // Set properties with $set and $set_once operations
-     * vTilt.setUserProperties(
-     *   { name: 'John Doe', last_login: new Date().toISOString() },  // $set properties
-     *   { first_login: new Date().toISOString() }                     // $set_once properties
-     * )
-     * ```
-     *
-     * @param userPropertiesToSet Optional: Properties to set (can be updated)
-     * @param userPropertiesToSetOnce Optional: Properties to set once (preserves first value)
-     */
-    setUserProperties(userPropertiesToSet, userPropertiesToSetOnce) {
-        // Update user properties in UserManager
-        // Returns true if properties were updated (not a duplicate), false otherwise
-        const shouldSendEvent = this.userManager.setUserProperties(userPropertiesToSet, userPropertiesToSetOnce);
-        // Only send $set event if properties were actually updated (not a duplicate)
-        if (shouldSendEvent) {
-            this.capture("$set", {
-                $set: userPropertiesToSet || {},
-                $set_once: userPropertiesToSetOnce || {},
-            });
-        }
-    }
-    /**
-     * Reset user identity (logout)
-     * Clears all user data, generates new anonymous ID, resets session
-     *
-     * @param reset_device_id - If true, also resets device_id. Default: false
-     *
-     * @example
-     * // Reset on user logout
-     * vtilt.resetUser()
-     *
-     * @example
-     * // Reset and generate new device ID
-     * vtilt.resetUser(true)
-     */
-    resetUser(reset_device_id) {
-        // Reset session ID
-        this.sessionManager.resetSessionId();
-        this.userManager.reset(reset_device_id);
-    }
-    /**
-     * Get current user identity
-     */
-    getUserIdentity() {
-        return this.userManager.getUserIdentity();
-    }
-    /**
-     * Get current device ID
-     */
-    getDeviceId() {
-        return this.userManager.getDeviceId();
-    }
-    /**
-     * Get current user state
-     */
-    getUserState() {
-        return this.userManager.getUserState();
-    }
-    /**
-     * Create an alias to link two distinct IDs
-     * Links anonymous session to account on signup
-     *
-     * @param alias - A unique identifier that you want to use for this user in the future
-     * @param original - The current identifier being used for this user (optional, defaults to current distinct_id)
-     *
-     * @example
-     * // Link anonymous user to account on signup
-     * vtilt.createAlias('user_12345')
-     *
-     * @example
-     * // Explicit alias with original ID
-     * vtilt.createAlias('user_12345', 'anonymous_abc123')
-     */
-    createAlias(alias, original) {
-        // Get alias information from UserManager
-        const aliasInfo = this.userManager.createAlias(alias, original);
-        // If alias was created, send $alias event
-        if (aliasInfo) {
-            this.capture("$alias", {
-                $original_id: aliasInfo.original,
-                $alias_id: aliasInfo.distinct_id,
-            });
-        }
-        else {
-            // If alias matches original, use identify instead
-            const distinctId = original ||
-                this.userManager.getDistinctId() ||
-                this.userManager.getAnonymousId();
-            if (alias === distinctId) {
-                this.identify(alias);
-            }
-        }
-    }
-    /**
-     * Capture initial pageview with visibility check
-     * Note: The capture_pageview config check happens at the call site (in _init)
-     */
-    _capture_initial_pageview() {
-        if (!globals_1.document) {
-            return;
-        }
-        // If page is not visible, add a listener to detect when the page becomes visible
-        // and trigger the pageview only then
-        // This is useful to avoid `prerender` calls from Chrome/Wordpress/SPAs
-        // that are not visible to the user
-        if (globals_1.document.visibilityState !== "visible") {
-            if (!this._visibility_state_listener) {
-                this._visibility_state_listener = () => {
-                    this._capture_initial_pageview();
-                };
-                (0, utils_1.addEventListener)(globals_1.document, "visibilitychange", this._visibility_state_listener);
-            }
-            return;
-        }
-        // Extra check here to guarantee we only ever trigger a single initial pageview event
-        if (!this._initial_pageview_captured) {
-            this._initial_pageview_captured = true;
-            // Wait a bit for SPA routers
-            setTimeout(() => {
-                // Double-check we're still in browser environment (defensive check)
-                if (!globals_1.document || !globals_1.location) {
-                    return;
-                }
-                // Note: $current_url, $host, $pathname, $referrer, $referring_domain, title
-                // are automatically added by capture() for all events (title only for $pageview)
-                const payload = {
-                    navigation_type: "initial_load",
-                };
-                this.capture("$pageview", payload);
-            }, 300);
-            // After we've captured the initial pageview, we can remove the listener
-            if (this._visibility_state_listener) {
-                globals_1.document.removeEventListener("visibilitychange", this._visibility_state_listener);
-                this._visibility_state_listener = null;
-            }
-        }
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return this.configManager.getConfig();
-    }
-    /**
-     * Get current session ID
-     */
-    getSessionId() {
-        return this.sessionManager.getSessionId();
-    }
-    /**
-     * Get current distinct ID
-     */
-    getDistinctId() {
-        return (this.userManager.getDistinctId() || this.userManager.getAnonymousId());
-    }
-    /**
-     * Get anonymous ID
-     */
-    getAnonymousId() {
-        return this.userManager.getAnonymousId();
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(config) {
-        this.configManager.updateConfig(config);
-        const fullConfig = this.configManager.getConfig();
-        // Recreate managers with new config
-        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", fullConfig.cross_subdomain_cookie);
-        // Default to localStorage+cookie for better SSR support (following PostHog)
-        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage+cookie", fullConfig.cross_subdomain_cookie);
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
-        // Update session recording config if it exists
-        if (this.sessionRecording && fullConfig.session_recording) {
-            this.sessionRecording.updateConfig(this._buildSessionRecordingConfig(fullConfig));
-        }
-    }
-    // ============================================================================
-    // Session Recording
-    // ============================================================================
-    /**
-     * Initialize session recording
-     */
-    _initSessionRecording() {
-        const config = this.configManager.getConfig();
-        // Don't initialize if explicitly disabled
-        if (config.disable_session_recording) {
-            return;
-        }
-        // Build session recording config
-        const sessionRecordingConfig = this._buildSessionRecordingConfig(config);
-        // Create session recording wrapper (lightweight - actual recorder is lazy-loaded)
-        this.sessionRecording = new replay_1.SessionRecordingWrapper(this, sessionRecordingConfig);
-        // Start recording if enabled (this will lazy-load the recorder script)
-        if (sessionRecordingConfig.enabled) {
-            this.sessionRecording.startIfEnabledOrStop("recording_initialized");
-        }
-    }
-    /**
-     * Build session recording config from VTiltConfig
-     */
-    _buildSessionRecordingConfig(config) {
-        var _a, _b, _c;
-        const sessionRecording = config.session_recording || {};
-        return {
-            enabled: (_a = sessionRecording.enabled) !== null && _a !== void 0 ? _a : false,
-            sampleRate: sessionRecording.sampleRate,
-            minimumDurationMs: sessionRecording.minimumDurationMs,
-            sessionIdleThresholdMs: sessionRecording.sessionIdleThresholdMs,
-            fullSnapshotIntervalMs: sessionRecording.fullSnapshotIntervalMs,
-            captureConsole: (_b = sessionRecording.captureConsole) !== null && _b !== void 0 ? _b : false,
-            captureNetwork: (_c = sessionRecording.captureNetwork) !== null && _c !== void 0 ? _c : false,
-            captureCanvas: sessionRecording.captureCanvas,
-            blockClass: sessionRecording.blockClass,
-            blockSelector: sessionRecording.blockSelector,
-            ignoreClass: sessionRecording.ignoreClass,
-            maskTextClass: sessionRecording.maskTextClass,
-            maskTextSelector: sessionRecording.maskTextSelector,
-            maskAllInputs: sessionRecording.maskAllInputs,
-            maskInputOptions: sessionRecording.maskInputOptions,
-            masking: sessionRecording.masking,
-            recordHeaders: sessionRecording.recordHeaders,
-            recordBody: sessionRecording.recordBody,
-            compressEvents: sessionRecording.compressEvents,
-            __mutationThrottlerRefillRate: sessionRecording.__mutationThrottlerRefillRate,
-            __mutationThrottlerBucketSize: sessionRecording.__mutationThrottlerBucketSize,
-        };
-    }
-    /**
-     * Start session recording
-     * Call this to manually start recording if it wasn't enabled initially
-     */
-    startSessionRecording() {
-        if (!this.sessionRecording) {
-            const config = this.configManager.getConfig();
-            const sessionRecordingConfig = this._buildSessionRecordingConfig(config);
-            sessionRecordingConfig.enabled = true;
-            this.sessionRecording = new replay_1.SessionRecordingWrapper(this, sessionRecordingConfig);
-        }
-        this.sessionRecording.startIfEnabledOrStop("recording_initialized");
-    }
-    /**
-     * Stop session recording
-     */
-    stopSessionRecording() {
-        var _a;
-        (_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.stopRecording();
-    }
-    /**
-     * Check if session recording is active
-     */
-    isRecordingActive() {
-        var _a;
-        return ((_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.status) === "active";
-    }
-    /**
-     * Get session recording ID
-     */
-    getSessionRecordingId() {
-        var _a;
-        return ((_a = this.sessionRecording) === null || _a === void 0 ? void 0 : _a.sessionId) || null;
-    }
-    // ============================================================================
-    // Chat
-    // ============================================================================
-    /**
-     * Initialize chat widget
-     */
-    _initChat() {
-        const config = this.configManager.getConfig();
-        // Don't initialize if explicitly disabled
-        if (config.disable_chat) {
-            return;
-        }
-        // Build chat config from VTiltConfig
-        const chatConfig = this._buildChatConfig(config);
-        // Create chat wrapper (lightweight - actual chat is lazy-loaded)
-        this.chat = new chat_wrapper_1.ChatWrapper(this, chatConfig);
-        // Start chat if enabled (this will fetch server settings and show bubble)
-        this.chat.startIfEnabled();
-    }
-    /**
-     * Build chat config from VTiltConfig
-     */
-    _buildChatConfig(config) {
-        var _a;
-        const chat = config.chat || {};
-        return {
-            enabled: chat.enabled,
-            autoConfig: (_a = chat.autoConfig) !== null && _a !== void 0 ? _a : true, // Default to auto-config from dashboard
-            position: chat.position,
-            greeting: chat.greeting,
-            color: chat.color,
-            aiMode: chat.aiMode,
-            aiGreeting: chat.aiGreeting,
-            preload: chat.preload,
-            offlineMessage: chat.offlineMessage,
-            collectEmailOffline: chat.collectEmailOffline,
-        };
-    }
-    /**
-     * _execute_array() deals with processing any vTilt function
-     * calls that were called before the vTilt library was loaded
-     * (and are thus stored in an array so they can be called later)
-     *
-     * Note: we fire off all the vTilt function calls BEFORE we fire off
-     * tracking calls. This is so identify/setUserProperties/updateConfig calls
-     * can properly modify early tracking calls.
-     *
-     * @param {Array} array Array of queued calls in format [methodName, ...args]
-     */
-    _execute_array(array) {
-        if (!Array.isArray(array)) {
-            return;
-        }
-        array.forEach((item) => {
-            if (item && Array.isArray(item) && item.length > 0) {
-                const methodName = item[0];
-                const args = item.slice(1);
-                if (typeof this[methodName] === "function") {
-                    try {
-                        this[methodName](...args);
-                    }
-                    catch (error) {
-                        console.error(`vTilt: Error executing queued call ${methodName}:`, error);
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * Called when DOM is loaded - processes queued requests and enables batching
-     * Following PostHog's pattern in _dom_loaded()
-     */
-    _dom_loaded() {
-        // Process all pre-init queued requests
-        this.__request_queue.forEach((item) => {
-            this._send_retriable_request(item);
-        });
-        // Clear the legacy queue
-        this.__request_queue = [];
-        // Enable the request queue for batched sending (PostHog pattern)
-        this._start_queue_if_opted_in();
-    }
-}
-exports.VTilt = VTilt;
-const instances = {};
-const PRIMARY_INSTANCE_NAME = "vt";
-// Browser support detection for request queuing
-// IE<10 does not support cross-origin XHR's but script tags
-// with defer won't block window.onload; ENQUEUE_REQUESTS
-// should only be true for Opera<12
-const SUPPORTS_REQUEST = typeof globals_1.XMLHttpRequest !== "undefined" || typeof globals_1.fetch !== "undefined";
-let ENQUEUE_REQUESTS = !SUPPORTS_REQUEST &&
-    (globals_1.userAgent === null || globals_1.userAgent === void 0 ? void 0 : globals_1.userAgent.indexOf("MSIE")) === -1 &&
-    (globals_1.userAgent === null || globals_1.userAgent === void 0 ? void 0 : globals_1.userAgent.indexOf("Mozilla")) === -1;
-// Expose ENQUEUE_REQUESTS to window for request queuing
-// Use typeof check to safely access global window object
-if (typeof globals_1.window !== "undefined" && globals_1.window !== null) {
-    globals_1.window.__VTILT_ENQUEUE_REQUESTS = ENQUEUE_REQUESTS;
-}
-/**
- * Add DOM loaded handler to process queued requests
- */
-const add_dom_loaded_handler = function () {
-    // Cross browser DOM Loaded support
-    function dom_loaded_handler() {
-        // function flag since we only want to execute this once
-        if (dom_loaded_handler.done) {
-            return;
-        }
-        dom_loaded_handler.done = true;
-        // Disable request queuing now that DOM is loaded
-        ENQUEUE_REQUESTS = false;
-        if (typeof globals_1.window !== "undefined" && globals_1.window !== null) {
-            globals_1.window.__VTILT_ENQUEUE_REQUESTS = false;
-        }
-        // Process queued requests for all instances
-        (0, utils_1.each)(instances, function (inst) {
-            inst._dom_loaded();
-        });
-    }
-    if (globals_1.document && typeof globals_1.document.addEventListener === "function") {
-        if (globals_1.document.readyState === "complete") {
-            // Safari 4 can fire the DOMContentLoaded event before loading all
-            // external JS (including this file). you will see some copypasta
-            // on the internet that checks for 'complete' and 'loaded', but
-            // 'loaded' is an IE thing
-            dom_loaded_handler();
-        }
-        else {
-            (0, utils_1.addEventListener)(globals_1.document, "DOMContentLoaded", dom_loaded_handler, {
-                capture: false,
-            });
-        }
-        return;
-    }
-    // Only IE6-8 don't support `document.addEventListener` and we don't support them
-    // so let's simply log an error stating vTilt couldn't be initialized
-    // We're checking for `window` to avoid erroring out on a SSR context
-    if (globals_1.window) {
-        console.error("Browser doesn't support `document.addEventListener` so vTilt couldn't be initialized");
-    }
-};
-/**
- * Initialize vTilt as a module
- * Returns an uninitialized vTilt instance that the user must call init() on
- */
-function init_as_module() {
-    const vTiltMain = (instances[PRIMARY_INSTANCE_NAME] = new VTilt());
-    add_dom_loaded_handler();
-    return vTiltMain;
-}
-/**
- * Initialize vTilt from snippet
- * Processes queued calls from the snippet stub and replaces it with real instance
- *
- * The snippet uses some clever tricks to allow deferred loading of array.js (this code)
- *
- * window.vt is an array which the queue of calls made before the lib is loaded
- * It has methods attached to it to simulate the vt object so for instance
- *
- * window.vt.init("projectId", {token: "token", host: "host"})
- * window.vt.trackEvent("my-event", {foo: "bar"})
- *
- * ... will mean that window.vt will look like this:
- * window.vt == [
- *   ["trackEvent", "my-event", {foo: "bar"}]
- * ]
- *
- * window.vt._i == [
- *   ["projectId", {token: "token", host: "host"}, "vt"]
- * ]
- *
- * If a name is given to the init function then the same as above is true but as a sub-property on the object:
- *
- * window.vt.init("projectId", {token: "token"}, "vt2")
- * window.vt.vt2.trackEvent("my-event", {foo: "bar"})
- *
- * window.vt.vt2 == [
- *   ["trackEvent", "my-event", {foo: "bar"}]
- * ]
- */
-function init_from_snippet() {
-    const vTiltMain = (instances[PRIMARY_INSTANCE_NAME] = new VTilt());
-    const snippetVT = globals_1.assignableWindow["vt"];
-    if (snippetVT) {
-        /**
-         * The snippet uses some clever tricks to allow deferred loading of array.js (this code)
-         *
-         * window.vt is an array which the queue of calls made before the lib is loaded
-         * It has methods attached to it to simulate the vt object so for instance
-         *
-         * window.vt.init("projectId", {token: "token", host: "host"})
-         * window.vt.trackEvent("my-event", {foo: "bar"})
-         *
-         * ... will mean that window.vt will look like this:
-         * window.vt == [
-         *   ["trackEvent", "my-event", {foo: "bar"}]
-         * ]
-         *
-         * window.vt._i == [
-         *   ["projectId", {token: "token", host: "host"}, "vt"]
-         * ]
-         *
-         * If a name is given to the init function then the same as above is true but as a sub-property on the object:
-         *
-         * window.vt.init("projectId", {token: "token"}, "vt2")
-         * window.vt.vt2.trackEvent("my-event", {foo: "bar"})
-         *
-         * window.vt.vt2 == [
-         *   ["trackEvent", "my-event", {foo: "bar"}]
-         * ]
-         *
-         */
-        // Call all pre-loaded init calls properly
-        (0, utils_1.each)(snippetVT["_i"], function (item) {
-            if (item && isArray(item)) {
-                const instance = vTiltMain.init(item[0], item[1], item[2]);
-                const instanceSnippet = snippetVT[item[2] || "vt"] || snippetVT;
-                if (instance) {
-                    // Execute all queued calls for this instance
-                    instance._execute_array(instanceSnippet);
-                }
-            }
-        });
-    }
-    globals_1.assignableWindow["vt"] = vTiltMain;
-    add_dom_loaded_handler();
-}