@v-tilt/browser 1.1.2 → 1.1.4

package/lib/user-manager.js

@@ -1,16 +1,35 @@
 "use strict";
+/**
+ * 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"
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserManager = void 0;
 const constants_1 = require("./constants");
 const utils_1 = require("./utils");
 const event_utils_1 = require("./utils/event-utils");
+const storage_1 = require("./storage");
 class UserManager {
     constructor(storageMethod = "localStorage", domain) {
         this._cachedPersonProperties = null; // Cache for deduplication
-        this.storageMethod = storageMethod;
-        this.domain = domain;
+        this.storage = new storage_1.StorageManager({
+            method: storageMethod,
+            domain,
+            sameSite: "Lax",
+        });
         this.userIdentity = this.loadUserIdentity();
     }
+    // ============================================================================
+    // Public Getters
+    // ============================================================================
     /**
      * Get current user identity
      */
@@ -30,8 +49,7 @@ class UserManager {
         if (!this.userIdentity.anonymous_id) {
             // Regenerate if somehow undefined
             this.userIdentity.anonymous_id = this.generateAnonymousId();
-            // Save to storage
-            this.setStoredValue(constants_1.ANONYMOUS_ID_KEY, this.userIdentity.anonymous_id);
+            this.storage.set(constants_1.ANONYMOUS_ID_KEY, this.userIdentity.anonymous_id, storage_1.USER_COOKIE_MAX_AGE);
         }
         return this.userIdentity.anonymous_id;
     }
@@ -41,6 +59,27 @@ class UserManager {
     getUserProperties() {
         return { ...this.userIdentity.properties };
     }
+    /**
+     * Get the effective ID for event tracking
+     */
+    getEffectiveId() {
+        return this.userIdentity.distinct_id || this.getAnonymousId();
+    }
+    /**
+     * Get current device ID
+     */
+    getDeviceId() {
+        return this.userIdentity.device_id;
+    }
+    /**
+     * Get current user state
+     */
+    getUserState() {
+        return this.userIdentity.user_state;
+    }
+    // ============================================================================
+    // Identity Operations
+    // ============================================================================
     /**
      * Identify a user with distinct ID and properties
      */
@@ -148,25 +187,6 @@ class UserManager {
     }
     /**
      * 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, userPropertiesToSetOnce) {
         // Return early if no properties provided
@@ -203,23 +223,9 @@ class UserManager {
         // Note: Event sending is now handled by VTilt.setUserProperties()
         return true;
     }
-    /**
-     * Get hash for person properties
-     * Used for deduplication of identical setUserProperties calls
-     */
-    getPersonPropertiesHash(distinctId, userPropertiesToSet, userPropertiesToSetOnce) {
-        // Create deterministic hash from distinct_id and properties
-        return JSON.stringify({
-            distinct_id: distinctId,
-            userPropertiesToSet,
-            userPropertiesToSetOnce,
-        });
-    }
     /**
      * 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) {
         // Generate completely new anonymous ID (don't revert to original)
@@ -245,24 +251,9 @@ class UserManager {
         };
         this.saveUserIdentity();
     }
-    /**
-     * Get the effective ID for event tracking
-     */
-    getEffectiveId() {
-        return this.userIdentity.distinct_id || this.getAnonymousId();
-    }
-    /**
-     * Get current device ID
-     */
-    getDeviceId() {
-        return this.userIdentity.device_id;
-    }
-    /**
-     * Get current user state
-     */
-    getUserState() {
-        return this.userIdentity.user_state;
-    }
+    // ============================================================================
+    // Internal Setters (for VTilt class)
+    // ============================================================================
     /**
      * Update distinct ID (internal use - for VTilt)
      */
@@ -312,21 +303,11 @@ class UserManager {
             this.saveUserIdentity();
         }
     }
-    /**
-     * Check if distinct ID is string-like (hardcoded string) - public for validation
-     * This is a wrapper to expose the private method
-     */
-    isDistinctIdStringLikePublic(distinctId) {
-        return this.isDistinctIdStringLike(distinctId);
-    }
+    // ============================================================================
+    // Alias Operations
+    // ============================================================================
     /**
      * 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
      */
     createAlias(alias, original) {
         if (!this.isValidDistinctId(alias)) {
@@ -355,75 +336,58 @@ class UserManager {
         return aliasEvent;
     }
     /**
-     * Validate distinct ID to prevent hardcoded strings
+     * Check if distinct ID is string-like (hardcoded string) - public for validation
      */
-    isValidDistinctId(distinctId) {
-        if (!distinctId || typeof distinctId !== "string") {
-            return false;
-        }
-        // Validation patterns
-        const invalidPatterns = [
-            "null",
-            "undefined",
-            "false",
-            "true",
-            "anonymous",
-            "anon",
-            "user",
-            "test",
-            "guest",
-            "visitor",
-            "unknown",
-            "none",
-        ];
-        const lower = distinctId.toLowerCase().trim();
-        if (invalidPatterns.includes(lower)) {
-            return false;
-        }
-        // Check for empty or whitespace-only strings
-        if (distinctId.trim().length === 0) {
-            return false;
+    isDistinctIdStringLikePublic(distinctId) {
+        return this.isDistinctIdStringLike(distinctId);
+    }
+    // ============================================================================
+    // Initial Person Info
+    // ============================================================================
+    /**
+     * Set initial person info
+     */
+    set_initial_person_info(maskPersonalDataProperties, customPersonalDataProperties) {
+        const stored = this.getStoredUserProperties();
+        // Check if already set (backwards compatibility check)
+        if (stored[constants_1.INITIAL_PERSON_INFO]) {
+            return;
         }
-        return true;
+        const personInfo = (0, event_utils_1.getPersonInfo)(maskPersonalDataProperties, customPersonalDataProperties);
+        this.register_once({
+            [constants_1.INITIAL_PERSON_INFO]: personInfo,
+        }, undefined);
     }
     /**
-     * Check if distinct ID is string-like (hardcoded string)
+     * Get initial props
      */
-    isDistinctIdStringLike(distinctId) {
-        if (!distinctId || typeof distinctId !== "string") {
-            return false;
+    get_initial_props() {
+        const stored = this.getStoredUserProperties();
+        const initialPersonInfo = stored[constants_1.INITIAL_PERSON_INFO];
+        if (!initialPersonInfo) {
+            return {};
         }
-        // Hardcoded string patterns
-        const hardcodedPatterns = [
-            "null",
-            "undefined",
-            "false",
-            "true",
-            "anonymous",
-            "anon",
-            "user",
-            "test",
-            "guest",
-            "visitor",
-            "unknown",
-            "none",
-            "demo",
-            "example",
-            "sample",
-            "placeholder",
-        ];
-        const lower = distinctId.toLowerCase().trim();
-        return hardcodedPatterns.includes(lower);
+        return (0, event_utils_1.getInitialPersonPropsFromInfo)(initialPersonInfo);
     }
+    /**
+     * Update referrer info
+     */
+    update_referrer_info() {
+        const referrerInfo = (0, event_utils_1.getReferrerInfo)();
+        this.register_once(referrerInfo, undefined);
+    }
+    // ============================================================================
+    // Storage Operations (using StorageManager)
+    // ============================================================================
     /**
      * Load user identity from storage
      */
     loadUserIdentity() {
-        const anonymousId = this.getStoredValue(constants_1.ANONYMOUS_ID_KEY) || this.generateAnonymousId();
-        const distinctId = this.getStoredValue(constants_1.DISTINCT_ID_KEY) || null;
-        const deviceId = this.getStoredValue(constants_1.DEVICE_ID_KEY) || this.generateDeviceId();
+        const anonymousId = this.storage.get(constants_1.ANONYMOUS_ID_KEY) || this.generateAnonymousId();
+        const distinctId = this.storage.get(constants_1.DISTINCT_ID_KEY) || null;
+        const deviceId = this.storage.get(constants_1.DEVICE_ID_KEY) || this.generateDeviceId();
         const properties = this.getStoredUserProperties();
-        const userState = this.getStoredValue(constants_1.USER_STATE_KEY) ||
+        const userState = this.storage.get(constants_1.USER_STATE_KEY) ||
             "anonymous";
         // Ensure anonymous_id is never undefined
         const safeAnonymousId = anonymousId || this.generateAnonymousId();
@@ -440,167 +404,31 @@ class UserManager {
      * Save user identity to storage
      */
     saveUserIdentity() {
-        this.setStoredValue(constants_1.ANONYMOUS_ID_KEY, this.userIdentity.anonymous_id);
-        this.setStoredValue(constants_1.DEVICE_ID_KEY, this.userIdentity.device_id);
-        this.setStoredValue(constants_1.USER_STATE_KEY, this.userIdentity.user_state);
+        this.storage.set(constants_1.ANONYMOUS_ID_KEY, this.userIdentity.anonymous_id, storage_1.USER_COOKIE_MAX_AGE);
+        this.storage.set(constants_1.DEVICE_ID_KEY, this.userIdentity.device_id, storage_1.USER_COOKIE_MAX_AGE);
+        this.storage.set(constants_1.USER_STATE_KEY, this.userIdentity.user_state, storage_1.USER_COOKIE_MAX_AGE);
         if (this.userIdentity.distinct_id) {
-            this.setStoredValue(constants_1.DISTINCT_ID_KEY, this.userIdentity.distinct_id);
+            this.storage.set(constants_1.DISTINCT_ID_KEY, this.userIdentity.distinct_id, storage_1.USER_COOKIE_MAX_AGE);
         }
         else {
-            this.removeStoredValue(constants_1.DISTINCT_ID_KEY);
+            this.storage.remove(constants_1.DISTINCT_ID_KEY);
         }
         this.setStoredUserProperties(this.userIdentity.properties);
     }
-    /**
-     * Generate a new anonymous ID
-     */
-    generateAnonymousId() {
-        return `anon_${(0, utils_1.uuidv4)()}`;
-    }
-    /**
-     * Generate a new device ID
-     */
-    generateDeviceId() {
-        return `device_${(0, utils_1.uuidv4)()}`;
-    }
-    /**
-     * Get stored value from storage
-     */
-    getStoredValue(key) {
-        try {
-            // Memory mode doesn't persist - return null (will use in-memory userIdentity)
-            if (this.storageMethod === constants_1.PERSISTENCE_METHODS.memory) {
-                return null;
-            }
-            if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStorage ||
-                this.storageMethod === constants_1.PERSISTENCE_METHODS.localStoragePlusCookie) {
-                // Try localStorage first for localStorage and localStorage+cookie modes
-                const value = localStorage.getItem(key);
-                if (value !== null) {
-                    return value;
-                }
-                // Fall back to cookie for localStorage+cookie mode
-                if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStoragePlusCookie) {
-                    return this.getCookieValue(key);
-                }
-                return null;
-            }
-            else {
-                // Cookie-only mode
-                return this.getCookieValue(key);
-            }
-        }
-        catch (error) {
-            // If storage access fails, return null
-            console.warn("Failed to access storage:", error);
-            return null;
-        }
-    }
-    /**
-     * Set stored value in storage
-     */
-    setStoredValue(key, value) {
-        try {
-            // Memory mode doesn't persist
-            if (this.storageMethod === constants_1.PERSISTENCE_METHODS.memory) {
-                return;
-            }
-            if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStorage) {
-                localStorage.setItem(key, value);
-            }
-            else if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStoragePlusCookie) {
-                // Store in both localStorage and cookie
-                localStorage.setItem(key, value);
-                this.setCookieValue(key, value);
-            }
-            else {
-                // Cookie-only mode
-                this.setCookieValue(key, value);
-            }
-        }
-        catch (error) {
-            // If storage access fails, log warning but don't throw
-            console.warn("Failed to save to storage:", error);
-        }
-    }
-    /**
-     * Remove stored value from storage
-     */
-    removeStoredValue(key) {
-        // Memory mode doesn't persist
-        if (this.storageMethod === constants_1.PERSISTENCE_METHODS.memory) {
-            return;
-        }
-        if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStorage) {
-            localStorage.removeItem(key);
-        }
-        else if (this.storageMethod === constants_1.PERSISTENCE_METHODS.localStoragePlusCookie) {
-            // Remove from both localStorage and cookie
-            localStorage.removeItem(key);
-            this.removeCookieValue(key);
-        }
-        else {
-            // Cookie-only mode
-            this.removeCookieValue(key);
-        }
-    }
     /**
      * Get user properties from storage
      */
     getStoredUserProperties() {
-        const stored = this.getStoredValue(constants_1.USER_PROPERTIES_KEY);
-        if (!stored) {
-            return {};
-        }
-        try {
-            return JSON.parse(stored);
-        }
-        catch (_a) {
-            return {};
-        }
+        return this.storage.getJSON(constants_1.USER_PROPERTIES_KEY) || {};
     }
     /**
      * Set user properties in storage
      */
     setStoredUserProperties(properties) {
-        this.setStoredValue(constants_1.USER_PROPERTIES_KEY, JSON.stringify(properties));
-    }
-    /**
-     * Get cookie value
-     */
-    getCookieValue(name) {
-        const cookies = document.cookie.split(";");
-        for (const cookie of cookies) {
-            const [key, value] = cookie.trim().split("=");
-            if (key === name) {
-                return decodeURIComponent(value);
-            }
-        }
-        return null;
-    }
-    /**
-     * Set cookie value
-     */
-    setCookieValue(name, value) {
-        let cookieValue = `${name}=${encodeURIComponent(value)}; Max-Age=31536000; path=/; secure; SameSite=Lax`;
-        if (this.domain) {
-            cookieValue += `; domain=${this.domain}`;
-        }
-        document.cookie = cookieValue;
-    }
-    /**
-     * Remove cookie value
-     */
-    removeCookieValue(name) {
-        let cookieValue = `${name}=; Max-Age=0; path=/`;
-        if (this.domain) {
-            cookieValue += `; domain=${this.domain}`;
-        }
-        document.cookie = cookieValue;
+        this.storage.setJSON(constants_1.USER_PROPERTIES_KEY, properties, storage_1.USER_COOKIE_MAX_AGE);
     }
     /**
      * Register a value once (only if not already set)
-     * Stores properties in localStorage only if they don't already exist
      */
     register_once(props, defaultValues) {
         const stored = this.getStoredUserProperties();
@@ -627,41 +455,103 @@ class UserManager {
             this.setStoredUserProperties(stored);
         }
     }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
     /**
-     * Set initial person info
-     * Stores referrer and URL info on first visit for generating $initial_* properties
+     * Generate a new anonymous ID
      */
-    set_initial_person_info(maskPersonalDataProperties, customPersonalDataProperties) {
-        const stored = this.getStoredUserProperties();
-        // Check if already set (backwards compatibility check)
-        if (stored[constants_1.INITIAL_PERSON_INFO]) {
-            return;
+    generateAnonymousId() {
+        return `anon_${(0, utils_1.uuidv4)()}`;
+    }
+    /**
+     * Generate a new device ID
+     */
+    generateDeviceId() {
+        return `device_${(0, utils_1.uuidv4)()}`;
+    }
+    /**
+     * Get hash for person properties (for deduplication)
+     */
+    getPersonPropertiesHash(distinctId, userPropertiesToSet, userPropertiesToSetOnce) {
+        return JSON.stringify({
+            distinct_id: distinctId,
+            userPropertiesToSet,
+            userPropertiesToSetOnce,
+        });
+    }
+    /**
+     * Validate distinct ID
+     */
+    isValidDistinctId(distinctId) {
+        if (!distinctId || typeof distinctId !== "string") {
+            return false;
         }
-        const personInfo = (0, event_utils_1.getPersonInfo)(maskPersonalDataProperties, customPersonalDataProperties);
-        this.register_once({
-            [constants_1.INITIAL_PERSON_INFO]: personInfo,
-        }, undefined);
+        const invalidPatterns = [
+            "null",
+            "undefined",
+            "false",
+            "true",
+            "anonymous",
+            "anon",
+            "user",
+            "test",
+            "guest",
+            "visitor",
+            "unknown",
+            "none",
+        ];
+        const lower = distinctId.toLowerCase().trim();
+        if (invalidPatterns.includes(lower)) {
+            return false;
+        }
+        if (distinctId.trim().length === 0) {
+            return false;
+        }
+        return true;
     }
     /**
-     * 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() {
-        const stored = this.getStoredUserProperties();
-        const initialPersonInfo = stored[constants_1.INITIAL_PERSON_INFO];
-        if (!initialPersonInfo) {
-            return {};
+    isDistinctIdStringLike(distinctId) {
+        if (!distinctId || typeof distinctId !== "string") {
+            return false;
         }
-        return (0, event_utils_1.getInitialPersonPropsFromInfo)(initialPersonInfo);
+        const hardcodedPatterns = [
+            "null",
+            "undefined",
+            "false",
+            "true",
+            "anonymous",
+            "anon",
+            "user",
+            "test",
+            "guest",
+            "visitor",
+            "unknown",
+            "none",
+            "demo",
+            "example",
+            "sample",
+            "placeholder",
+        ];
+        const lower = distinctId.toLowerCase().trim();
+        return hardcodedPatterns.includes(lower);
     }
+    // ============================================================================
+    // Storage Management
+    // ============================================================================
     /**
-     * Update referrer info
-     * Stores current referrer information if not already stored
+     * Update storage method at runtime
      */
-    update_referrer_info() {
-        const referrerInfo = (0, event_utils_1.getReferrerInfo)();
-        this.register_once(referrerInfo, undefined);
+    updateStorageMethod(method, domain) {
+        this.storage = new storage_1.StorageManager({
+            method,
+            domain,
+            sameSite: "Lax",
+        });
+        // Reload identity from new storage
+        this.userIdentity = this.loadUserIdentity();
     }
 }
 exports.UserManager = UserManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@v-tilt/browser",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "vTilt browser tracking library",
   "main": "dist/main.js",
   "module": "dist/module.js",