@v-tilt/browser 1.1.2 → 1.1.4

package/dist/session.d.ts

@@ -1,59 +1,41 @@
+/**
+ * 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
+ */
 import { PersistenceMethod } from "./types";
 export declare class SessionManager {
-    private storageMethod;
-    private domain?;
+    private storage;
     private _windowId;
     constructor(storageMethod?: PersistenceMethod, domain?: string);
     /**
-     * Check if using web storage (localStorage or sessionStorage)
-     */
-    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 cookie
+     * Get session ID (always returns a value, generates if needed)
      */
-    private getSessionIdFromCookie;
+    getSessionId(): string;
     /**
-     * Set session ID in cookie
+     * Set session ID in storage
+     * Extends TTL if session_id exists, generates new one if not
      */
-    private setSessionIdFromCookie;
+    setSessionId(): string;
     /**
-     * Store session ID (in web storage or cookie)
+     * Reset session ID (generates new session on reset)
      */
-    private _storeSessionId;
+    resetSessionId(): void;
     /**
      * Get session ID from storage (raw, can return null)
-     * Private method used internally
      */
     private _getSessionIdRaw;
     /**
-     * Get session ID (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
+     * Store session ID
      */
-    setSessionId(): string;
+    private _storeSessionId;
     /**
      * Clear session ID from storage
      */
     private _clearSessionId;
-    /**
-     * Reset session ID (generates new session on reset)
-     */
-    resetSessionId(): void;
     /**
      * Get window ID
      * Window ID is unique per browser tab/window and persists across page reloads
@@ -65,11 +47,6 @@ export declare class SessionManager {
      * 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
      * Detects tab duplication and handles window_id persistence
@@ -80,4 +57,8 @@ export declare class SessionManager {
      * This helps distinguish between page reloads and tab duplication
      */
     private _listenToUnload;
+    /**
+     * Update storage method at runtime
+     */
+    updateStorageMethod(method: PersistenceMethod, domain?: string): void;
 }

package/dist/storage.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Unified Storage Manager - Following PostHog's PostHogPersistence pattern
+ *
+ * Single class handles all storage operations for both sessions and users.
+ * Reduces code duplication and ensures consistent cookie handling.
+ *
+ * Storage methods:
+ * - cookie: Browser cookies (cross-subdomain support)
+ * - localStorage: Persistent local storage
+ * - sessionStorage: Tab-specific storage (cleared on tab close)
+ * - localStorage+cookie: Both for redundancy
+ * - memory: In-memory only (no persistence)
+ */
+import { PersistenceMethod } from "./types";
+export declare const SESSION_COOKIE_MAX_AGE = 1800;
+export declare const USER_COOKIE_MAX_AGE = 31536000;
+export interface StorageOptions {
+    method: PersistenceMethod;
+    domain?: string;
+    secure?: boolean;
+    sameSite?: "Strict" | "Lax" | "None";
+}
+export interface StorageItem<T = string> {
+    value: T;
+    expiry?: number;
+}
+/**
+ * Unified Storage Manager
+ * Provides consistent storage operations across all persistence methods
+ */
+export declare class StorageManager {
+    private method;
+    private domain?;
+    private secure;
+    private sameSite;
+    private memoryStorage;
+    constructor(options: StorageOptions);
+    /**
+     * Get a value from storage
+     */
+    get(key: string): string | null;
+    /**
+     * Set a value in storage
+     * @param maxAge - Cookie max age in seconds (ignored for localStorage/sessionStorage)
+     */
+    set(key: string, value: string, maxAge?: number): void;
+    /**
+     * Remove a value from storage
+     */
+    remove(key: string): void;
+    /**
+     * Get JSON value with expiry check
+     * Returns null if expired or not found
+     */
+    getWithExpiry<T>(key: string): T | null;
+    /**
+     * Set JSON value with optional expiry
+     * @param ttlMs - Time to live in milliseconds
+     */
+    setWithExpiry<T>(key: string, value: T, ttlMs?: number): void;
+    /**
+     * Get JSON value (no expiry check)
+     */
+    getJSON<T>(key: string): T | null;
+    /**
+     * Set JSON value
+     */
+    setJSON<T>(key: string, value: T, maxAge?: number): void;
+    private getCookie;
+    private setCookie;
+    private removeCookie;
+    private usesLocalStorage;
+    private usesSessionStorage;
+    /**
+     * Check if sessionStorage is available
+     */
+    canUseSessionStorage(): boolean;
+    /**
+     * Get direct access to sessionStorage (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;
+}
+/**
+ * Create a shared storage instance
+ * Use this for creating storage managers with consistent settings
+ */
+export declare function createStorageManager(method: PersistenceMethod, domain?: string): StorageManager;

package/dist/user-manager.d.ts

@@ -1,7 +1,18 @@
+/**
+ * User Manager - Handles user identity and properties
+ *
+ * Uses shared StorageManager for consistent storage operations.
+ *
+ * Manages:
+ * - anonymous_id: Generated ID for anonymous users
+ * - distinct_id: User-provided ID after identification
+ * - device_id: Persistent device identifier
+ * - user_properties: Custom properties set via identify/setUserProperties
+ * - user_state: "anonymous" or "identified"
+ */
 import { UserIdentity, AliasEvent, PersistenceMethod } from "./types";
 export declare class UserManager {
-    private storageMethod;
-    private domain?;
+    private storage;
     private userIdentity;
     private _cachedPersonProperties;
     constructor(storageMethod?: PersistenceMethod, domain?: string);
@@ -21,57 +32,31 @@ export declare class UserManager {
      * Get current user properties
      */
     getUserProperties(): Record<string, any>;
+    /**
+     * Get the effective ID for event tracking
+     */
+    getEffectiveId(): string;
+    /**
+     * Get current device ID
+     */
+    getDeviceId(): string;
+    /**
+     * Get current user state
+     */
+    getUserState(): "anonymous" | "identified";
     /**
      * Identify a user with distinct ID and properties
      */
     identify(newDistinctId?: string, userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
     /**
      * Set user properties without changing distinct ID
-     * Sets properties on the person profile associated with the current distinct_id
-     *
-     * @example
-     * ```js
-     * // Set properties that can be updated
-     * vt.setUserProperties({ name: 'John Doe', email: 'john@example.com' })
-     * ```
-     *
-     * @example
-     * ```js
-     * // Set properties with $set and $set_once operations
-     * vt.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?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): boolean;
-    /**
-     * Get hash for person properties
-     * Used for deduplication of identical setUserProperties calls
-     */
-    private getPersonPropertiesHash;
     /**
      * Reset user identity (logout)
      * Generates new anonymous ID, clears user data, optionally resets device ID
-     *
-     * @param reset_device_id - If true, also resets device_id. Default: false (preserves device_id)
      */
     reset(reset_device_id?: boolean): void;
-    /**
-     * Get the effective ID for event tracking
-     */
-    getEffectiveId(): string;
-    /**
-     * Get current device ID
-     */
-    getDeviceId(): string;
-    /**
-     * Get current user state
-     */
-    getUserState(): "anonymous" | "identified";
     /**
      * Update distinct ID (internal use - for VTilt)
      */
@@ -88,29 +73,26 @@ export declare class UserManager {
      * Set device ID if not already set (internal use - for VTilt)
      */
     ensureDeviceId(deviceId: string): void;
+    /**
+     * Create an alias to link two distinct IDs
+     */
+    createAlias(alias: string, original?: string): AliasEvent | null;
     /**
      * Check if distinct ID is string-like (hardcoded string) - public for validation
-     * This is a wrapper to expose the private method
      */
     isDistinctIdStringLikePublic(distinctId: string): boolean;
     /**
-     * Create an alias to link two distinct IDs
-     * If original is not provided, uses current distinct_id
-     * If alias matches original, returns null (caller should use identify instead)
-     *
-     * @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)
-     * @returns AliasEvent if alias was created, null if alias matches original or invalid
+     * Set initial person info
      */
-    createAlias(alias: string, original?: string): AliasEvent | null;
+    set_initial_person_info(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[]): void;
     /**
-     * Validate distinct ID to prevent hardcoded strings
+     * Get initial props
      */
-    private isValidDistinctId;
+    get_initial_props(): Record<string, any>;
     /**
-     * Check if distinct ID is string-like (hardcoded string)
+     * Update referrer info
      */
-    private isDistinctIdStringLike;
+    update_referrer_info(): void;
     /**
      * Load user identity from storage
      */
@@ -119,26 +101,6 @@ export declare class UserManager {
      * Save user identity to storage
      */
     private saveUserIdentity;
-    /**
-     * Generate a new anonymous ID
-     */
-    private generateAnonymousId;
-    /**
-     * Generate a new device ID
-     */
-    private generateDeviceId;
-    /**
-     * Get stored value from storage
-     */
-    private getStoredValue;
-    /**
-     * Set stored value in storage
-     */
-    private setStoredValue;
-    /**
-     * Remove stored value from storage
-     */
-    private removeStoredValue;
     /**
      * Get user properties from storage
      */
@@ -148,36 +110,31 @@ export declare class UserManager {
      */
     private setStoredUserProperties;
     /**
-     * Get cookie value
+     * Register a value once (only if not already set)
      */
-    private getCookieValue;
+    private register_once;
     /**
-     * Set cookie value
+     * Generate a new anonymous ID
      */
-    private setCookieValue;
+    private generateAnonymousId;
     /**
-     * Remove cookie value
+     * Generate a new device ID
      */
-    private removeCookieValue;
+    private generateDeviceId;
     /**
-     * Register a value once (only if not already set)
-     * Stores properties in localStorage only if they don't already exist
+     * Get hash for person properties (for deduplication)
      */
-    private register_once;
+    private getPersonPropertiesHash;
     /**
-     * Set initial person info
-     * Stores referrer and URL info on first visit for generating $initial_* properties
+     * Validate distinct ID
      */
-    set_initial_person_info(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[]): void;
+    private isValidDistinctId;
     /**
-     * Get initial props
-     * Generates $initial_* properties from stored initial person info
-     * These are sent with events as $set_once to preserve first values
+     * Check if distinct ID is string-like (hardcoded string)
      */
-    get_initial_props(): Record<string, any>;
+    private isDistinctIdStringLike;
     /**
-     * Update referrer info
-     * Stores current referrer information if not already stored
+     * Update storage method at runtime
      */
-    update_referrer_info(): void;
+    updateStorageMethod(method: PersistenceMethod, domain?: string): void;
 }

package/lib/session.d.ts

@@ -1,59 +1,41 @@
+/**
+ * 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
+ */
 import { PersistenceMethod } from "./types";
 export declare class SessionManager {
-    private storageMethod;
-    private domain?;
+    private storage;
     private _windowId;
     constructor(storageMethod?: PersistenceMethod, domain?: string);
     /**
-     * Check if using web storage (localStorage or sessionStorage)
-     */
-    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 cookie
+     * Get session ID (always returns a value, generates if needed)
      */
-    private getSessionIdFromCookie;
+    getSessionId(): string;
     /**
-     * Set session ID in cookie
+     * Set session ID in storage
+     * Extends TTL if session_id exists, generates new one if not
      */
-    private setSessionIdFromCookie;
+    setSessionId(): string;
     /**
-     * Store session ID (in web storage or cookie)
+     * Reset session ID (generates new session on reset)
      */
-    private _storeSessionId;
+    resetSessionId(): void;
     /**
      * Get session ID from storage (raw, can return null)
-     * Private method used internally
      */
     private _getSessionIdRaw;
     /**
-     * Get session ID (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
+     * Store session ID
      */
-    setSessionId(): string;
+    private _storeSessionId;
     /**
      * Clear session ID from storage
      */
     private _clearSessionId;
-    /**
-     * Reset session ID (generates new session on reset)
-     */
-    resetSessionId(): void;
     /**
      * Get window ID
      * Window ID is unique per browser tab/window and persists across page reloads
@@ -65,11 +47,6 @@ export declare class SessionManager {
      * 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
      * Detects tab duplication and handles window_id persistence
@@ -80,4 +57,8 @@ export declare class SessionManager {
      * This helps distinguish between page reloads and tab duplication
      */
     private _listenToUnload;
+    /**
+     * Update storage method at runtime
+     */
+    updateStorageMethod(method: PersistenceMethod, domain?: string): void;
 }