@v-tilt/browser 1.0.5 → 1.0.7

package/dist/vtilt.d.ts

@@ -1,14 +1,59 @@
 import { VTiltConfig, EventPayload } from "./types";
+import { TrackingManager } from "./tracking";
+import { HistoryAutocapture } from "./extensions/history-autocapture";
 export declare class VTilt {
     private configManager;
-    private trackingManager;
+    trackingManager: TrackingManager;
     private webVitalsManager;
-    private initialized;
+    historyAutocapture?: HistoryAutocapture;
+    __loaded: boolean;
+    private _initialPageviewCaptured;
+    private _visibilityStateListener;
     constructor(config?: Partial<VTiltConfig>);
     /**
-     * Initialize VTilt tracking
+     * 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: string, config?: Partial<VTiltConfig>, name?: string): 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)
+     * Used for debugging and logging
+     *
+     * @internal
      */
-    init(): void;
+    toString(): string;
     /**
      * Track a custom event
      */
@@ -100,17 +145,10 @@ export declare class VTilt {
      */
     createAlias(alias: string, original?: string): void;
     /**
-     * Setup page tracking with history API support
-     */
-    private setupPageTracking;
-    /**
-     * Track page hit
-     */
-    private trackPageHit;
-    /**
-     * Setup visibility change tracking for prerendered pages
+     * Capture initial pageview with visibility check
+     * Based on PostHog's _captureInitialPageview implementation
      */
-    private setupVisibilityTracking;
+    private _captureInitialPageview;
     /**
      * Get current configuration
      */
@@ -124,11 +162,11 @@ export declare class VTilt {
      */
     updateConfig(config: Partial<VTiltConfig>): void;
     /**
-     * _execute_array() deals with processing any VTilt function
-     * calls that were called before the VTilt library was loaded
+     * _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
+     * 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.
      *
@@ -141,12 +179,12 @@ export declare class VTilt {
     _dom_loaded(): void;
 }
 /**
- * Initialize VTilt as a module (similar to PostHog's init_as_module)
- * Returns an uninitialized VTilt instance that the user must call init() on
+ * Initialize vTilt as a module (similar to PostHog's init_as_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 (similar to PostHog's init_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)

package/lib/constants.d.ts

@@ -1,5 +1,7 @@
 import { StorageMethods } from "./types";
 export declare const STORAGE_KEY = "vt_session_id";
+export declare const WINDOW_ID_KEY = "vt_window_id";
+export declare const PRIMARY_WINDOW_EXISTS_KEY = "vt_primary_window_exists";
 export declare const ANONYMOUS_ID_KEY = "vt_anonymous_id";
 export declare const DISTINCT_ID_KEY = "vt_distinct_id";
 export declare const DEVICE_ID_KEY = "vt_device_id";

package/lib/constants.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ATTRIBUTES_TO_MASK = exports.TIMEZONES = exports.STORAGE_METHODS = exports.USER_STATE_KEY = exports.USER_PROPERTIES_KEY = exports.DEVICE_ID_KEY = exports.DISTINCT_ID_KEY = exports.ANONYMOUS_ID_KEY = exports.STORAGE_KEY = void 0;
+exports.ATTRIBUTES_TO_MASK = exports.TIMEZONES = exports.STORAGE_METHODS = exports.USER_STATE_KEY = exports.USER_PROPERTIES_KEY = exports.DEVICE_ID_KEY = exports.DISTINCT_ID_KEY = exports.ANONYMOUS_ID_KEY = exports.PRIMARY_WINDOW_EXISTS_KEY = exports.WINDOW_ID_KEY = exports.STORAGE_KEY = void 0;
 exports.STORAGE_KEY = "vt_session_id";
+exports.WINDOW_ID_KEY = "vt_window_id";
+exports.PRIMARY_WINDOW_EXISTS_KEY = "vt_primary_window_exists";
 exports.ANONYMOUS_ID_KEY = "vt_anonymous_id";
 exports.DISTINCT_ID_KEY = "vt_distinct_id";
 exports.DEVICE_ID_KEY = "vt_device_id";

package/lib/extensions/history-autocapture.d.ts

@@ -0,0 +1,19 @@
+import { VTilt } from "../vtilt";
+/**
+ * This class is used to capture pageview events when the user navigates using the history API (pushState, replaceState)
+ * and when the user navigates using the browser's back/forward buttons.
+ *
+ * Based on PostHog's HistoryAutocapture implementation
+ */
+export declare class HistoryAutocapture {
+    private _instance;
+    private _popstateListener;
+    private _lastPathname;
+    constructor(instance: VTilt);
+    get isEnabled(): boolean;
+    startIfEnabled(): void;
+    stop(): void;
+    monitorHistoryChanges(): void;
+    private _capturePageview;
+    private _setupPopstateListener;
+}

package/lib/extensions/history-autocapture.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistoryAutocapture = void 0;
+const globals_1 = require("../utils/globals");
+const utils_1 = require("../utils");
+const patch_1 = require("../utils/patch");
+/**
+ * This class is used to capture pageview events when the user navigates using the history API (pushState, replaceState)
+ * and when the user navigates using the browser's back/forward buttons.
+ *
+ * Based on PostHog's HistoryAutocapture implementation
+ */
+class HistoryAutocapture {
+    constructor(instance) {
+        var _a;
+        this._instance = instance;
+        this._lastPathname = ((_a = globals_1.window === null || globals_1.window === void 0 ? void 0 : globals_1.window.location) === null || _a === void 0 ? void 0 : _a.pathname) || "";
+    }
+    get isEnabled() {
+        // For now, always enabled (vTilt always tracks pageviews)
+        // Can be made conditional based on config in the future
+        return true;
+    }
+    startIfEnabled() {
+        if (this.isEnabled) {
+            this.monitorHistoryChanges();
+        }
+    }
+    stop() {
+        if (this._popstateListener) {
+            this._popstateListener();
+        }
+        this._popstateListener = undefined;
+    }
+    monitorHistoryChanges() {
+        var _a, _b;
+        // Only setup page tracking in browser environment (not SSR)
+        if (!globals_1.window || !globals_1.location) {
+            return;
+        }
+        // Initialize last pathname
+        this._lastPathname = globals_1.location.pathname || "";
+        // Track history API changes using patch (PostHog-style)
+        if (globals_1.window.history) {
+            // Old fashioned, we could also use arrow functions but I think the closure for a patch is more reliable
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            // Only patch if not already wrapped
+            if (!((_a = globals_1.window.history.pushState) === null || _a === void 0 ? void 0 : _a.__vtilt_wrapped__)) {
+                (0, patch_1.patch)(globals_1.window.history, "pushState", (originalPushState) => {
+                    return function patchedPushState(state, title, url) {
+                        originalPushState.call(this, state, title, url);
+                        self._capturePageview("pushState");
+                    };
+                });
+            }
+            // Only patch if not already wrapped
+            if (!((_b = globals_1.window.history.replaceState) === null || _b === void 0 ? void 0 : _b.__vtilt_wrapped__)) {
+                (0, patch_1.patch)(globals_1.window.history, "replaceState", (originalReplaceState) => {
+                    return function patchedReplaceState(state, title, url) {
+                        originalReplaceState.call(this, state, title, url);
+                        self._capturePageview("replaceState");
+                    };
+                });
+            }
+            // For popstate we need to listen to the event instead of overriding a method
+            this._setupPopstateListener();
+        }
+    }
+    _capturePageview(navigationType) {
+        var _a;
+        try {
+            const currentPathname = (_a = globals_1.window === null || globals_1.window === void 0 ? void 0 : globals_1.window.location) === null || _a === void 0 ? void 0 : _a.pathname;
+            if (!currentPathname || !globals_1.location || !globals_1.document) {
+                return;
+            }
+            // Only capture pageview if the pathname has changed and the feature is enabled
+            if (currentPathname !== this._lastPathname && this.isEnabled) {
+                // Note: $current_url, $host, $pathname, $referrer, $referring_domain, title
+                // are automatically added by sendEvent() for all events (title only for $pageview)
+                const payload = {
+                    navigation_type: navigationType,
+                };
+                this._instance.trackingManager.sendEvent("$pageview", payload);
+            }
+            this._lastPathname = currentPathname;
+        }
+        catch (error) {
+            console.error(`Error capturing ${navigationType} pageview`, error);
+        }
+    }
+    _setupPopstateListener() {
+        if (this._popstateListener || !globals_1.window) {
+            return;
+        }
+        const handler = () => {
+            this._capturePageview("popstate");
+        };
+        (0, utils_1.addEventListener)(globals_1.window, "popstate", handler);
+        this._popstateListener = () => {
+            if (globals_1.window) {
+                globals_1.window.removeEventListener("popstate", handler);
+            }
+        };
+    }
+}
+exports.HistoryAutocapture = HistoryAutocapture;

package/lib/session.d.ts

@@ -2,25 +2,82 @@ import { StorageMethod } from "./types";
 export declare class SessionManager {
     private storageMethod;
     private domain?;
+    private _windowId;
     constructor(storageMethod?: StorageMethod, domain?: string);
     /**
-     * Get session ID from cookie
+     * Check if using web storage (localStorage or sessionStorage)
      */
-    private getSessionIdFromCookie;
+    private _isWebStorage;
+    /**
+     * Get storage object (localStorage or sessionStorage)
+     */
+    private _getStorage;
+    /**
+     * Create session data object with expiry
+     */
+    private _createSessionData;
+    /**
+     * Store session ID in web storage
+     */
+    private _storeSessionIdInWebStorage;
     /**
-     * Get session ID from storage
+     * Get session ID from cookie
      */
-    getSessionId(): string | null;
+    private getSessionIdFromCookie;
     /**
      * Set session ID in cookie
      */
     private setSessionIdFromCookie;
+    /**
+     * Store session ID (in web storage or cookie)
+     */
+    private _storeSessionId;
+    /**
+     * Get session ID from storage (raw, can return null)
+     * Private method used internally
+     */
+    private _getSessionIdRaw;
+    /**
+     * Get session ID (PostHog-style: always returns a value, generates if needed)
+     */
+    getSessionId(): string;
     /**
      * Set session ID in storage
+     * Extends TTL if session_id exists, generates new one if not
      */
     setSessionId(): string;
+    /**
+     * Clear session ID from storage
+     */
+    private _clearSessionId;
     /**
      * Reset session ID (PostHog behavior: generates new session on reset)
      */
     resetSessionId(): void;
+    /**
+     * Get window ID (PostHog-style)
+     * Window ID is unique per browser tab/window and persists across page reloads
+     * Always returns a window_id (generates one if not set)
+     */
+    getWindowId(): string;
+    /**
+     * Set window ID (PostHog-style)
+     * Stores in sessionStorage which is unique per tab
+     */
+    private _setWindowId;
+    /**
+     * Check if we can use sessionStorage for window_id
+     * sessionStorage is unique per tab, perfect for window_id
+     */
+    private _canUseSessionStorage;
+    /**
+     * Initialize window ID (PostHog-style)
+     * Detects tab duplication and handles window_id persistence
+     */
+    private _initializeWindowId;
+    /**
+     * Listen to window unload to clear primary window flag
+     * This helps distinguish between page reloads and tab duplication
+     */
+    private _listenToUnload;
 }

package/lib/session.js

@@ -3,10 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionManager = void 0;
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
+const globals_1 = require("./utils/globals");
 class SessionManager {
     constructor(storageMethod = "cookie", domain) {
         this.storageMethod = storageMethod;
         this.domain = domain;
+        this._windowId = undefined;
+        // Initialize window_id (PostHog-style)
+        this._initializeWindowId();
+    }
+    /**
+     * Check if using web storage (localStorage or sessionStorage)
+     */
+    _isWebStorage() {
+        return (this.storageMethod === constants_1.STORAGE_METHODS.localStorage ||
+            this.storageMethod === constants_1.STORAGE_METHODS.sessionStorage);
+    }
+    /**
+     * Get storage object (localStorage or sessionStorage)
+     */
+    _getStorage() {
+        if (!this._isWebStorage()) {
+            return null;
+        }
+        return this.storageMethod === constants_1.STORAGE_METHODS.localStorage
+            ? localStorage
+            : sessionStorage;
+    }
+    /**
+     * Create session data object with expiry
+     */
+    _createSessionData(sessionId) {
+        const now = new Date();
+        return {
+            value: sessionId,
+            expiry: now.getTime() + 1800 * 1000, // 30 minutes
+        };
+    }
+    /**
+     * Store session ID in web storage
+     */
+    _storeSessionIdInWebStorage(sessionId) {
+        const storage = this._getStorage();
+        if (!storage) {
+            return;
+        }
+        const item = this._createSessionData(sessionId);
+        storage.setItem(constants_1.STORAGE_KEY, JSON.stringify(item));
     }
     /**
      * Get session ID from cookie
@@ -20,14 +63,33 @@ class SessionManager {
         return cookie[constants_1.STORAGE_KEY] || null;
     }
     /**
-     * Get session ID from storage
+     * Set session ID in cookie
      */
-    getSessionId() {
-        if (this.storageMethod === constants_1.STORAGE_METHODS.localStorage ||
-            this.storageMethod === constants_1.STORAGE_METHODS.sessionStorage) {
-            const storage = this.storageMethod === constants_1.STORAGE_METHODS.localStorage
-                ? localStorage
-                : sessionStorage;
+    setSessionIdFromCookie(sessionId) {
+        let cookieValue = `${constants_1.STORAGE_KEY}=${sessionId}; Max-Age=1800; path=/; secure`;
+        if (this.domain) {
+            cookieValue += `; domain=${this.domain}`;
+        }
+        document.cookie = cookieValue;
+    }
+    /**
+     * Store session ID (in web storage or cookie)
+     */
+    _storeSessionId(sessionId) {
+        if (this._isWebStorage()) {
+            this._storeSessionIdInWebStorage(sessionId);
+        }
+        else {
+            this.setSessionIdFromCookie(sessionId);
+        }
+    }
+    /**
+     * Get session ID from storage (raw, can return null)
+     * Private method used internally
+     */
+    _getSessionIdRaw() {
+        const storage = this._getStorage();
+        if (storage) {
             const serializedItem = storage.getItem(constants_1.STORAGE_KEY);
             if (!serializedItem) {
                 return null;
@@ -52,17 +114,20 @@ class SessionManager {
         return this.getSessionIdFromCookie();
     }
     /**
-     * Set session ID in cookie
+     * Get session ID (PostHog-style: always returns a value, generates if needed)
      */
-    setSessionIdFromCookie(sessionId) {
-        let cookieValue = `${constants_1.STORAGE_KEY}=${sessionId}; Max-Age=1800; path=/; secure`;
-        if (this.domain) {
-            cookieValue += `; domain=${this.domain}`;
+    getSessionId() {
+        let sessionId = this._getSessionIdRaw();
+        // Generate and store session_id if not found (PostHog-style: always ensure session_id exists)
+        if (!sessionId) {
+            sessionId = (0, utils_1.uuidv4)();
+            this._storeSessionId(sessionId);
         }
-        document.cookie = cookieValue;
+        return sessionId;
     }
     /**
      * Set session ID in storage
+     * Extends TTL if session_id exists, generates new one if not
      */
     setSessionId() {
         /**
@@ -70,46 +135,137 @@ class SessionManager {
          *   - First request in a session will generate a new session id
          *   - The next request will keep the same session id and extend the TTL for 30 more minutes
          */
-        const sessionId = this.getSessionId() || (0, utils_1.uuidv4)();
-        if (this.storageMethod === constants_1.STORAGE_METHODS.localStorage ||
-            this.storageMethod === constants_1.STORAGE_METHODS.sessionStorage) {
-            const now = new Date();
-            const item = {
-                value: sessionId,
-                expiry: now.getTime() + 1800 * 1000,
-            };
-            const value = JSON.stringify(item);
-            const storage = this.storageMethod === constants_1.STORAGE_METHODS.localStorage
-                ? localStorage
-                : sessionStorage;
-            storage.setItem(constants_1.STORAGE_KEY, value);
-        }
-        else {
-            this.setSessionIdFromCookie(sessionId);
-        }
+        const sessionId = this._getSessionIdRaw() || (0, utils_1.uuidv4)();
+        this._storeSessionId(sessionId);
         return sessionId;
     }
     /**
-     * Reset session ID (PostHog behavior: generates new session on reset)
+     * Clear session ID from storage
      */
-    resetSessionId() {
-        // Clear existing session
-        if (this.storageMethod === constants_1.STORAGE_METHODS.localStorage ||
-            this.storageMethod === constants_1.STORAGE_METHODS.sessionStorage) {
-            const storage = this.storageMethod === constants_1.STORAGE_METHODS.localStorage
-                ? localStorage
-                : sessionStorage;
+    _clearSessionId() {
+        const storage = this._getStorage();
+        if (storage) {
             storage.removeItem(constants_1.STORAGE_KEY);
         }
         else {
             // Clear cookie
-            document.cookie = `${constants_1.STORAGE_KEY}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;`;
+            const expires = "Thu, 01 Jan 1970 00:00:00 UTC";
+            document.cookie = `${constants_1.STORAGE_KEY}=; expires=${expires}; path=/;`;
             if (this.domain) {
-                document.cookie = `${constants_1.STORAGE_KEY}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; domain=${this.domain};`;
+                document.cookie = `${constants_1.STORAGE_KEY}=; expires=${expires}; path=/; domain=${this.domain};`;
             }
         }
-        // Generate new session ID
+    }
+    /**
+     * Reset session ID (PostHog behavior: generates new session on reset)
+     */
+    resetSessionId() {
+        this._clearSessionId();
+        // Generate new session ID and window ID
         this.setSessionId();
+        this._setWindowId((0, utils_1.uuidv4)());
+    }
+    /**
+     * Get window ID (PostHog-style)
+     * Window ID is unique per browser tab/window and persists across page reloads
+     * Always returns a window_id (generates one if not set)
+     */
+    getWindowId() {
+        if (this._windowId) {
+            return this._windowId;
+        }
+        // Try to get from sessionStorage (unique per tab)
+        if (this._canUseSessionStorage() && globals_1.window) {
+            const windowId = globals_1.window.sessionStorage.getItem(constants_1.WINDOW_ID_KEY);
+            if (windowId) {
+                this._windowId = windowId;
+                return windowId;
+            }
+        }
+        // Generate and store window_id if not found (PostHog-style: always ensure window_id exists)
+        const newWindowId = (0, utils_1.uuidv4)();
+        this._setWindowId(newWindowId);
+        return newWindowId;
+    }
+    /**
+     * Set window ID (PostHog-style)
+     * Stores in sessionStorage which is unique per tab
+     */
+    _setWindowId(windowId) {
+        if (windowId !== this._windowId) {
+            this._windowId = windowId;
+            if (this._canUseSessionStorage() && globals_1.window) {
+                globals_1.window.sessionStorage.setItem(constants_1.WINDOW_ID_KEY, windowId);
+            }
+        }
+    }
+    /**
+     * Check if we can use sessionStorage for window_id
+     * sessionStorage is unique per tab, perfect for window_id
+     */
+    _canUseSessionStorage() {
+        if (typeof globals_1.window === "undefined" || !globals_1.window.sessionStorage) {
+            return false;
+        }
+        try {
+            const testKey = "__vt_session_storage_test__";
+            globals_1.window.sessionStorage.setItem(testKey, "test");
+            globals_1.window.sessionStorage.removeItem(testKey);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Initialize window ID (PostHog-style)
+     * Detects tab duplication and handles window_id persistence
+     */
+    _initializeWindowId() {
+        if (!this._canUseSessionStorage() || !globals_1.window) {
+            // Fallback: generate window_id in memory (won't persist across reloads)
+            this._windowId = (0, utils_1.uuidv4)();
+            return;
+        }
+        // Check if primary window exists flag is set
+        // If it exists, this means the tab was duplicated/cloned (window.open, tab duplication, etc.)
+        // If it doesn't exist, this is a fresh/reloaded tab
+        const primaryWindowExists = globals_1.window.sessionStorage.getItem(constants_1.PRIMARY_WINDOW_EXISTS_KEY);
+        const lastWindowId = globals_1.window.sessionStorage.getItem(constants_1.WINDOW_ID_KEY);
+        if (lastWindowId && !primaryWindowExists) {
+            // Tab was reloaded - reuse the window_id from sessionStorage
+            this._windowId = lastWindowId;
+        }
+        else {
+            // New tab or duplicated tab - generate new window_id
+            if (lastWindowId) {
+                // Clear old window_id (this is a duplicated tab)
+                globals_1.window.sessionStorage.removeItem(constants_1.WINDOW_ID_KEY);
+            }
+            // Generate new window_id
+            this._setWindowId((0, utils_1.uuidv4)());
+        }
+        // Flag this session as having a primary window
+        globals_1.window.sessionStorage.setItem(constants_1.PRIMARY_WINDOW_EXISTS_KEY, "true");
+        // Listen for page unload to clear the primary window flag
+        // This allows us to detect tab duplication vs page reload
+        this._listenToUnload();
+    }
+    /**
+     * Listen to window unload to clear primary window flag
+     * This helps distinguish between page reloads and tab duplication
+     */
+    _listenToUnload() {
+        if (!globals_1.window || !this._canUseSessionStorage()) {
+            return;
+        }
+        (0, utils_1.addEventListener)(globals_1.window, "beforeunload", () => {
+            // Clear the primary window flag on unload
+            // Reloaded tabs won't have this flag, duplicated tabs will
+            if (globals_1.window && globals_1.window.sessionStorage) {
+                globals_1.window.sessionStorage.removeItem(constants_1.PRIMARY_WINDOW_EXISTS_KEY);
+            }
+        }, { capture: false });
     }
 }
 exports.SessionManager = SessionManager;

package/lib/tracking.d.ts

@@ -23,6 +23,9 @@ export declare class TrackingManager {
     private _isConfigured;
     /**
      * Send event to endpoint
+     * PostHog-style: 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
      */
     sendEvent(name: string, payload: EventPayload): Promise<void>;
     /**
@@ -38,10 +41,6 @@ export declare class TrackingManager {
      * Send a queued request (called after DOM is loaded)
      */
     _send_retriable_request(item: QueuedRequest): void;
-    /**
-     * Track page hit
-     */
-    trackPageHit(): void;
     /**
      * Get current session ID
      */
@@ -94,6 +93,15 @@ export declare class TrackingManager {
      * Setup listener for identify, set, and alias events
      */
     private setupIdentifyListener;
+    /**
+     * Get session and window IDs (PostHog-style)
+     * Both methods ensure IDs always exist (generate if needed)
+     */
+    private _getSessionAndWindowIds;
+    /**
+     * Create base tracking event structure
+     */
+    private _createTrackingEvent;
     /**
      * Send identify event for session merging
      */