@v-tilt/browser 1.0.8 → 1.0.10

package/lib/vtilt.d.ts

@@ -1,14 +1,20 @@
 import { VTiltConfig, EventPayload } from "./types";
-import { TrackingManager } from "./tracking";
 import { HistoryAutocapture } from "./extensions/history-autocapture";
+interface QueuedRequest {
+    url: string;
+    event: any;
+}
 export declare class VTilt {
     private configManager;
-    trackingManager: TrackingManager;
+    private sessionManager;
+    private userManager;
     private webVitalsManager;
     historyAutocapture?: HistoryAutocapture;
     __loaded: boolean;
     private _initialPageviewCaptured;
     private _visibilityStateListener;
+    __request_queue: QueuedRequest[];
+    private _hasWarnedAboutConfig;
     constructor(config?: Partial<VTiltConfig>);
     /**
      * Initializes a new instance of the VTilt tracking object.
@@ -44,23 +50,57 @@ export declare class VTilt {
     /**
      * Handles the actual initialization logic for a VTilt instance.
      * This internal method should only be called by `init()`.
-     * Follows the PostHog convention of using a private `_init()` method for instance setup.
      */
     private _init;
     /**
-     * Returns a string representation of the instance name (PostHog-style)
+     * Returns a string representation of the instance name
      * Used for debugging and logging
      *
      * @internal
      */
     toString(): string;
     /**
-     * Track a custom event
+     * Get current domain from location
+     * Returns full URL format for consistency with dashboard
+     */
+    private getCurrentDomain;
+    /**
+     * 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
+     */
+    private _isConfigured;
+    /**
+     * Build the tracking URL with token in query parameters
+     */
+    private buildUrl;
+    /**
+     * Send HTTP request
+     * This is the central entry point for all tracking requests
+     */
+    private sendRequest;
+    /**
+     * Send a queued request (called after DOM is loaded)
+     */
+    _send_retriable_request(item: QueuedRequest): void;
+    /**
+     * Capture an event
+     * Automatically adds common properties to all events
+     * ($current_url, $host, $pathname, $referrer, $referring_domain, $browser_language, etc.)
+     * Also adds title property for $pageview events only
+     *
+     * @param name - Event name
+     * @param payload - Event payload
+     */
+    capture(name: string, payload: EventPayload): void;
+    /**
+     * Track a custom event (alias for capture)
      */
     trackEvent(name: string, payload?: EventPayload): void;
     /**
-     * Identify a user with PostHog-style property operations
-     * Copied from PostHog's identify method signature
+     * 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
@@ -77,9 +117,9 @@ export declare class VTilt {
      * vTilt.identify('user_123', { name: 'John Doe', email: 'john@example.com' })
      * ```
      */
-    identify(distinctId?: string, userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
+    identify(newDistinctId?: string, userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
     /**
-     * Set user properties with PostHog-style operations
+     * Set user properties
      * Sets properties on the person profile associated with the current distinct_id
      *
      * @example
@@ -103,7 +143,7 @@ export declare class VTilt {
     setUserProperties(userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
     /**
      * Reset user identity (logout)
-     * PostHog behavior: Clears all user data, generates new anonymous ID
+     * Clears all user data, generates new anonymous ID, resets session
      *
      * @param reset_device_id - If true, also resets device_id. Default: false
      *
@@ -130,7 +170,7 @@ export declare class VTilt {
     getUserState(): "anonymous" | "identified";
     /**
      * Create an alias to link two distinct IDs
-     * PostHog behavior: Links anonymous session to account on signup
+     * 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)
@@ -146,7 +186,6 @@ export declare class VTilt {
     createAlias(alias: string, original?: string): void;
     /**
      * Capture initial pageview with visibility check
-     * Based on PostHog's _captureInitialPageview implementation
      */
     private _captureInitialPageview;
     /**
@@ -179,12 +218,12 @@ export declare class VTilt {
     _dom_loaded(): void;
 }
 /**
- * Initialize vTilt as a module (similar to PostHog's init_as_module)
+ * Initialize vTilt as a module
  * Returns an uninitialized vTilt instance that the user must call init() on
  */
 export declare function init_as_module(): VTilt;
 /**
- * Initialize vTilt from snippet (similar to PostHog's init_from_snippet)
+ * 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)
@@ -214,3 +253,4 @@ export declare function init_as_module(): VTilt;
  * ]
  */
 export declare function init_from_snippet(): void;
+export {};

package/lib/vtilt.js

@@ -4,10 +4,12 @@ exports.VTilt = void 0;
 exports.init_as_module = init_as_module;
 exports.init_from_snippet = init_from_snippet;
 const config_1 = require("./config");
-const tracking_1 = require("./tracking");
+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 utils_1 = require("./utils");
+const event_utils_1 = require("./utils/event-utils");
 const globals_1 = require("./utils/globals");
 // Helper to check if value is an array
 const isArray = Array.isArray;
@@ -16,9 +18,18 @@ class VTilt {
         this.__loaded = false; // Matches snippet's window.vt.__loaded check
         this._initialPageviewCaptured = false;
         this._visibilityStateListener = null;
+        this.__request_queue = []; // Public for DOM loaded handler
+        this._hasWarnedAboutConfig = false; // Track if we've already warned about missing config
         this.configManager = new config_1.ConfigManager(config);
-        this.trackingManager = new tracking_1.TrackingManager(this.configManager.getConfig());
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(this.configManager.getConfig(), this.trackingManager);
+        const fullConfig = this.configManager.getConfig();
+        // Auto-detect domain from location if not provided
+        let domain = fullConfig.domain;
+        if (!domain && globals_1.location) {
+            domain = this.getCurrentDomain();
+        }
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
     }
     /**
      * Initializes a new instance of the VTilt tracking object.
@@ -68,7 +79,6 @@ class VTilt {
     /**
      * Handles the actual initialization logic for a VTilt instance.
      * This internal method should only be called by `init()`.
-     * Follows the PostHog convention of using a private `_init()` method for instance setup.
      */
     _init(projectId, config = {}, name) {
         // Guard: prevent re-initialization (matches snippet's __loaded check)
@@ -76,14 +86,14 @@ class VTilt {
             console.warn("vTilt: You have already initialized vTilt! Re-initializing is a no-op");
             return this;
         }
-        // Update config with projectId, token, and name (PostHog-style)
+        // Update config with projectId, token, and name
         this.updateConfig({
             ...config,
             projectId: projectId || config.projectId,
             name: name,
         });
         this.__loaded = true;
-        // Initialize history autocapture (PostHog-style)
+        // Initialize history autocapture
         this.historyAutocapture = new history_autocapture_1.HistoryAutocapture(this);
         this.historyAutocapture.startIfEnabled();
         // Capture initial pageview (with visibility check)
@@ -91,7 +101,7 @@ class VTilt {
         return this;
     }
     /**
-     * Returns a string representation of the instance name (PostHog-style)
+     * Returns a string representation of the instance name
      * Used for debugging and logging
      *
      * @internal
@@ -106,14 +116,191 @@ class VTilt {
         return name;
     }
     /**
-     * Track a custom event
+     * 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
+     */
+    _isConfigured() {
+        const config = this.configManager.getConfig();
+        if (config.projectId && config.token) {
+            return true;
+        }
+        // Only warn once to avoid console spam
+        if (!this._hasWarnedAboutConfig) {
+            console.warn("VTilt: projectId and token are required for tracking. " +
+                "Events will be skipped until init() or updateConfig() is called with these fields.");
+            this._hasWarnedAboutConfig = true;
+        }
+        return false;
+    }
+    /**
+     * Build the tracking URL with token in query parameters
+     */
+    buildUrl() {
+        const config = this.configManager.getConfig();
+        const { proxyUrl, proxy, host, token } = config;
+        // Use proxy endpoint to handle Tinybird 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 (host) {
+            const cleanHost = 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
+     */
+    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._isConfigured()) {
+            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;
+            }
+        }
+        const request = new XMLHttpRequest();
+        request.open("POST", url, true);
+        request.setRequestHeader("Content-Type", "application/json");
+        request.send(JSON.stringify(event));
+    }
+    /**
+     * 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_language, etc.)
+     * Also adds title property for $pageview events only
+     *
+     * @param name - Event name
+     * @param payload - Event payload
+     */
+    capture(name, payload) {
+        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;
+        }
+        const url = this.buildUrl();
+        // Add properties to all events
+        // This includes: $current_url, $host, $pathname, $referrer, $referring_domain, $browser_language, etc.
+        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 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();
+        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 } : {}),
+            ...payload, // User-provided payload (can override base and person properties)
+        };
+        // 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 || "",
+            domain: config.domain || this.getCurrentDomain(), // Use config domain or current domain
+            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);
+    }
+    /**
+     * Track a custom event (alias for capture)
      */
     trackEvent(name, payload = {}) {
-        this.trackingManager.sendEvent(name, payload);
+        this.capture(name, payload);
     }
     /**
-     * Identify a user with PostHog-style property operations
-     * Copied from PostHog's identify method signature
+     * 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
@@ -130,11 +317,76 @@ class VTilt {
      * vTilt.identify('user_123', { name: 'John Doe', email: 'john@example.com' })
      * ```
      */
-    identify(distinctId, userPropertiesToSet, userPropertiesToSetOnce) {
-        this.trackingManager.identify(distinctId, userPropertiesToSet, userPropertiesToSetOnce);
+    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: previousDistinctId || 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 with PostHog-style operations
+     * Set user properties
      * Sets properties on the person profile associated with the current distinct_id
      *
      * @example
@@ -156,11 +408,20 @@ class VTilt {
      * @param userPropertiesToSetOnce Optional: Properties to set once (preserves first value)
      */
     setUserProperties(userPropertiesToSet, userPropertiesToSetOnce) {
-        this.trackingManager.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)
-     * PostHog behavior: Clears all user data, generates new anonymous ID
+     * Clears all user data, generates new anonymous ID, resets session
      *
      * @param reset_device_id - If true, also resets device_id. Default: false
      *
@@ -173,29 +434,31 @@ class VTilt {
      * vtilt.resetUser(true)
      */
     resetUser(reset_device_id) {
-        this.trackingManager.resetUser(reset_device_id);
+        // Reset session ID
+        this.sessionManager.resetSessionId();
+        this.userManager.reset(reset_device_id);
     }
     /**
      * Get current user identity
      */
     getUserIdentity() {
-        return this.trackingManager.getUserIdentity();
+        return this.userManager.getUserIdentity();
     }
     /**
      * Get current device ID
      */
     getDeviceId() {
-        return this.trackingManager.getDeviceId();
+        return this.userManager.getDeviceId();
     }
     /**
      * Get current user state
      */
     getUserState() {
-        return this.trackingManager.getUserState();
+        return this.userManager.getUserState();
     }
     /**
      * Create an alias to link two distinct IDs
-     * PostHog behavior: Links anonymous session to account on signup
+     * 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)
@@ -209,11 +472,27 @@ class VTilt {
      * vtilt.createAlias('user_12345', 'anonymous_abc123')
      */
     createAlias(alias, original) {
-        this.trackingManager.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
-     * Based on PostHog's _captureInitialPageview implementation
      */
     _captureInitialPageview() {
         if (!globals_1.document) {
@@ -235,18 +514,18 @@ class VTilt {
         // Extra check here to guarantee we only ever trigger a single initial pageview event
         if (!this._initialPageviewCaptured) {
             this._initialPageviewCaptured = true;
-            // Wait a bit for SPA routers (PostHog-style delay)
+            // 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 sendEvent() for all events (title only for $pageview)
+                // are automatically added by capture() for all events (title only for $pageview)
                 const payload = {
                     navigation_type: "initial_load",
                 };
-                this.trackingManager.sendEvent("$pageview", payload);
+                this.capture("$pageview", payload);
             }, 300);
             // After we've captured the initial pageview, we can remove the listener
             if (this._visibilityStateListener) {
@@ -265,16 +544,22 @@ class VTilt {
      * Get current session ID
      */
     getSessionId() {
-        return this.trackingManager.getSessionId();
+        return this.sessionManager.getSessionId();
     }
     /**
      * Update configuration
      */
     updateConfig(config) {
         this.configManager.updateConfig(config);
+        const fullConfig = this.configManager.getConfig();
         // Recreate managers with new config
-        this.trackingManager = new tracking_1.TrackingManager(this.configManager.getConfig());
-        this.webVitalsManager = new web_vitals_1.WebVitalsManager(this.configManager.getConfig(), this.trackingManager);
+        let domain = fullConfig.domain;
+        if (!domain && globals_1.location) {
+            domain = this.getCurrentDomain();
+        }
+        this.sessionManager = new session_1.SessionManager(fullConfig.storage || "cookie", domain);
+        this.userManager = new user_manager_1.UserManager(fullConfig.persistence || "localStorage", domain);
+        this.webVitalsManager = new web_vitals_1.WebVitalsManager(fullConfig, this);
     }
     /**
      * _execute_array() deals with processing any vTilt function
@@ -310,14 +595,12 @@ class VTilt {
      * Called when DOM is loaded - processes queued requests
      */
     _dom_loaded() {
-        if (this.trackingManager) {
-            // Process all queued requests
-            this.trackingManager.__request_queue.forEach((item) => {
-                this.trackingManager._send_retriable_request(item);
-            });
-            // Clear the queue
-            this.trackingManager.__request_queue = [];
-        }
+        // Process all queued requests
+        this.__request_queue.forEach((item) => {
+            this._send_retriable_request(item);
+        });
+        // Clear the queue
+        this.__request_queue = [];
     }
 }
 exports.VTilt = VTilt;
@@ -331,13 +614,12 @@ const SUPPORTS_REQUEST = typeof globals_1.XMLHttpRequest !== "undefined" || type
 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 TrackingManager to access
+// Expose ENQUEUE_REQUESTS to window for request queuing
 if (globals_1.window) {
     globals_1.window.__VTILT_ENQUEUE_REQUESTS = ENQUEUE_REQUESTS;
 }
 /**
  * Add DOM loaded handler to process queued requests
- * Similar to PostHog's add_dom_loaded_handler
  */
 const add_dom_loaded_handler = function () {
     // Cross browser DOM Loaded support
@@ -380,7 +662,7 @@ const add_dom_loaded_handler = function () {
     }
 };
 /**
- * Initialize vTilt as a module (similar to PostHog's init_as_module)
+ * Initialize vTilt as a module
  * Returns an uninitialized vTilt instance that the user must call init() on
  */
 function init_as_module() {
@@ -389,7 +671,7 @@ function init_as_module() {
     return vTiltMain;
 }
 /**
- * Initialize vTilt from snippet (similar to PostHog's init_from_snippet)
+ * 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)