@v-tilt/browser 1.5.1 → 1.7.0

package/lib/session.js

@@ -1,191 +0,0 @@
-"use strict";
-/**
- * Session Manager - Handles session_id and window_id
- *
- * Uses shared StorageManager for consistent storage operations.
- *
- * Session ID: Unique per user session, expires after 30 minutes of inactivity
- * Window ID: Unique per browser tab, persists across page reloads
- */
-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");
-const storage_1 = require("./storage");
-class SessionManager {
-    constructor(storageMethod = "cookie", cross_subdomain) {
-        this.storage = new storage_1.StorageManager({
-            method: storageMethod,
-            cross_subdomain,
-            sameSite: "Lax",
-        });
-        this._windowId = undefined;
-        // Initialize window_id
-        this._initializeWindowId();
-    }
-    // ============================================================================
-    // Session ID Operations
-    // ============================================================================
-    /**
-     * Get session ID (always returns a value, generates if needed)
-     */
-    getSessionId() {
-        let sessionId = this._getSessionIdRaw();
-        // Generate and store session_id if not found (always ensure session_id exists)
-        if (!sessionId) {
-            sessionId = (0, utils_1.uuidv4)();
-            this._storeSessionId(sessionId);
-        }
-        return sessionId;
-    }
-    /**
-     * Set session ID in storage
-     * Extends TTL if session_id exists, generates new one if not
-     */
-    setSessionId() {
-        /**
-         * Try to keep same session id if it exists, generate a new one otherwise.
-         *   - 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._getSessionIdRaw() || (0, utils_1.uuidv4)();
-        this._storeSessionId(sessionId);
-        return sessionId;
-    }
-    /**
-     * Reset session ID (generates new session on reset)
-     */
-    resetSessionId() {
-        this._clearSessionId();
-        // Generate new session ID and window ID
-        this.setSessionId();
-        this._setWindowId((0, utils_1.uuidv4)());
-    }
-    /**
-     * Get session ID from storage (raw, can return null)
-     * Cookie Max-Age handles expiration automatically
-     */
-    _getSessionIdRaw() {
-        return this.storage.get(constants_1.STORAGE_KEY);
-    }
-    /**
-     * Store session ID
-     * Uses plain string format - cookie Max-Age handles expiration
-     */
-    _storeSessionId(sessionId) {
-        this.storage.set(constants_1.STORAGE_KEY, sessionId, storage_1.SESSION_COOKIE_MAX_AGE);
-    }
-    /**
-     * Clear session ID from storage
-     */
-    _clearSessionId() {
-        this.storage.remove(constants_1.STORAGE_KEY);
-    }
-    // ============================================================================
-    // Window ID Operations
-    // ============================================================================
-    /**
-     * Get window ID
-     * 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)
-        const sessionStorage = this.storage.getSessionStorage();
-        if (sessionStorage) {
-            const windowId = sessionStorage.getItem(constants_1.WINDOW_ID_KEY);
-            if (windowId) {
-                this._windowId = windowId;
-                return windowId;
-            }
-        }
-        // Generate and store window_id if not found (always ensure window_id exists)
-        const newWindowId = (0, utils_1.uuidv4)();
-        this._setWindowId(newWindowId);
-        return newWindowId;
-    }
-    /**
-     * Set window ID
-     * Stores in sessionStorage which is unique per tab
-     */
-    _setWindowId(windowId) {
-        if (windowId !== this._windowId) {
-            this._windowId = windowId;
-            const sessionStorage = this.storage.getSessionStorage();
-            if (sessionStorage) {
-                sessionStorage.setItem(constants_1.WINDOW_ID_KEY, windowId);
-            }
-        }
-    }
-    /**
-     * Initialize window ID
-     * Detects tab duplication and handles window_id persistence
-     */
-    _initializeWindowId() {
-        const sessionStorage = this.storage.getSessionStorage();
-        if (!sessionStorage) {
-            // 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 = sessionStorage.getItem(constants_1.PRIMARY_WINDOW_EXISTS_KEY);
-        const lastWindowId = 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)
-                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
-        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() {
-        const sessionStorage = this.storage.getSessionStorage();
-        if (!globals_1.window || !sessionStorage) {
-            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
-            const ss = this.storage.getSessionStorage();
-            if (ss) {
-                ss.removeItem(constants_1.PRIMARY_WINDOW_EXISTS_KEY);
-            }
-        }, { capture: false });
-    }
-    // ============================================================================
-    // Storage Management
-    // ============================================================================
-    /**
-     * Update storage method at runtime
-     */
-    updateStorageMethod(method, cross_subdomain) {
-        this.storage = new storage_1.StorageManager({
-            method,
-            cross_subdomain,
-            sameSite: "Lax",
-        });
-    }
-}
-exports.SessionManager = SessionManager;

package/lib/storage.d.ts

@@ -1,117 +0,0 @@
-/**
- * Unified Storage Manager
- *
- * Handles all storage operations for sessions and users with consistent
- * cookie handling across different persistence methods.
- *
- * Storage methods:
- * - `cookie`: Browser cookies with cross-subdomain support
- * - `localStorage`: Persistent local storage
- * - `sessionStorage`: Tab-specific storage (cleared on tab close)
- * - `localStorage+cookie`: Hybrid mode (default) - full data in localStorage,
- *   critical identity properties also in cookies for SSR support
- * - `memory`: In-memory only (no persistence)
- *
- * The `localStorage+cookie` mode is designed for traditional server-side
- * rendered websites where each page navigation reloads JavaScript:
- * - Critical properties (anonymous_id, device_id, etc.) are stored in cookies
- * - Cookies ensure identity persists across full page reloads
- * - localStorage provides fast access for SPA-style navigation
- * - Falls back to cookie-only if localStorage is unavailable
- */
-import { PersistenceMethod } from "./types";
-/**
- * Critical properties persisted to cookies in `localStorage+cookie` mode.
- * These ensure identity survives full page reloads in traditional SSR websites.
- */
-export declare const COOKIE_PERSISTED_PROPERTIES: readonly ["__vt_anonymous_id", "__vt_device_id", "__vt_distinct_id", "__vt_user_state"];
-/** Session cookie TTL: 30 minutes */
-export declare const SESSION_COOKIE_MAX_AGE = 1800;
-/** User cookie TTL: 1 year */
-export declare const USER_COOKIE_MAX_AGE = 31536000;
-export interface StorageOptions {
-    method: PersistenceMethod;
-    /** Enable cross-subdomain cookies (auto-detected if not specified) */
-    cross_subdomain?: boolean;
-    /** Use secure cookies (auto-detected from protocol if not specified) */
-    secure?: boolean;
-    /** Cookie SameSite attribute */
-    sameSite?: "Strict" | "Lax" | "None";
-}
-export interface StorageItem<T = string> {
-    value: T;
-    expiry?: number;
-}
-/**
- * Check if cross-subdomain cookies should be enabled.
- * Returns false for shared hosting platforms to prevent cookie conflicts.
- */
-export declare function shouldUseCrossSubdomainCookie(): boolean;
-/**
- * Unified Storage Manager
- *
- * Provides consistent storage operations across all persistence methods
- * with automatic fallbacks and SSR support.
- */
-export declare class StorageManager {
-    private method;
-    private cross_subdomain;
-    private secure;
-    private sameSite;
-    private memoryStorage;
-    private _localStorageSupported;
-    constructor(options: StorageOptions);
-    /** Check if localStorage is available (result is cached) */
-    private isLocalStorageSupported;
-    /** Check if a key should be persisted to cookies */
-    private isCriticalProperty;
-    /**
-     * Get a value from storage.
-     *
-     * For `localStorage+cookie` mode:
-     * - Critical properties: read cookie first (for SSR), fall back to localStorage
-     * - Non-critical properties: read from localStorage only
-     */
-    get(key: string): string | null;
-    /**
-     * Set a value in storage.
-     * @param maxAge Cookie max age in seconds (only for cookie-based storage)
-     *
-     * For `localStorage+cookie` mode:
-     * - All values stored in localStorage (if available)
-     * - Critical properties ALWAYS stored in cookies for SSR support
-     */
-    set(key: string, value: string, maxAge?: number): void;
-    /** Remove a value from storage */
-    remove(key: string): void;
-    private getLocalStoragePlusCookie;
-    private setLocalStoragePlusCookie;
-    private removeLocalStoragePlusCookie;
-    private getLocalStorage;
-    private setLocalStorage;
-    private removeLocalStorage;
-    private readFromSessionStorage;
-    private writeToSessionStorage;
-    private removeFromSessionStorage;
-    private getCookie;
-    private setCookie;
-    private removeCookie;
-    /** Get JSON value with expiry check */
-    getWithExpiry<T>(key: string): T | null;
-    /** Set JSON value with optional TTL */
-    setWithExpiry<T>(key: string, value: T, ttlMs?: number): void;
-    /** Get parsed JSON value */
-    getJSON<T>(key: string): T | null;
-    /** Set JSON value */
-    setJSON<T>(key: string, value: T, maxAge?: number): void;
-    /** Check if sessionStorage is available */
-    canUseSessionStorage(): boolean;
-    /** Get sessionStorage instance (for window_id which always uses sessionStorage) */
-    getSessionStorage(): Storage | null;
-    /** Update storage method at runtime */
-    setMethod(method: PersistenceMethod): void;
-    /** Get current storage method */
-    getMethod(): PersistenceMethod;
-}
-/** Factory function to create a StorageManager with default settings */
-export declare function createStorageManager(method: PersistenceMethod, cross_subdomain?: boolean): StorageManager;