@journium/react 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -667,14 +667,47 @@ class BrowserIdentityManager {
     }
 }
 
+class Logger {
+    static setDebug(enabled) {
+        this.isDebugEnabled = enabled;
+    }
+    static isDebug() {
+        return this.isDebugEnabled;
+    }
+    static log(...args) {
+        if (this.isDebugEnabled) {
+            console.log(...args);
+        }
+    }
+    static warn(...args) {
+        if (this.isDebugEnabled) {
+            console.warn(...args);
+        }
+    }
+    static error(...args) {
+        if (this.isDebugEnabled) {
+            console.error(...args);
+        }
+    }
+    static info(...args) {
+        if (this.isDebugEnabled) {
+            console.info(...args);
+        }
+    }
+}
+Logger.isDebugEnabled = false;
+
 class JourniumClient {
     constructor(config) {
+        var _a;
         this.queue = [];
         this.flushTimer = null;
         this.initialized = false;
+        this.optionsChangeCallbacks = new Set();
         // Validate required configuration
         if (!config.publishableKey) {
-            console.error('Journium: publishableKey is required but not provided. SDK will not function.');
+            Logger.setDebug(true);
+            Logger.error('Journium: publishableKey is required but not provided. SDK will not function.');
             return;
         }
         // Set default apiHost if not provided
@@ -696,6 +729,8 @@ class JourniumClient {
         if (this.config.options) {
             this.effectiveOptions = mergeOptions(defaultOptions, this.config.options);
         }
+        // Initialize Logger with debug setting
+        Logger.setDebug((_a = this.effectiveOptions.debug) !== null && _a !== void 0 ? _a : false);
         // Initialize identity manager
         this.identityManager = new BrowserIdentityManager(this.effectiveOptions.sessionTimeout, this.config.publishableKey);
         // Initialize synchronously with cached config, fetch fresh config in background
@@ -703,7 +738,6 @@ class JourniumClient {
         this.fetchRemoteOptionsAsync();
     }
     loadCachedOptions() {
-        var _a;
         if (typeof window === 'undefined' || !window.localStorage) {
             return null;
         }
@@ -712,14 +746,11 @@ class JourniumClient {
             return cached ? JSON.parse(cached) : null;
         }
         catch (error) {
-            if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
-                console.warn('Journium: Failed to load cached config:', error);
-            }
+            Logger.warn('Journium: Failed to load cached config:', error);
             return null;
         }
     }
     saveCachedOptions(options) {
-        var _a;
         if (typeof window === 'undefined' || !window.localStorage) {
             return;
         }
@@ -727,30 +758,34 @@ class JourniumClient {
             window.localStorage.setItem(this.optionsStorageKey, JSON.stringify(options));
         }
         catch (error) {
-            if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
-                console.warn('Journium: Failed to save config to cache:', error);
-            }
+            Logger.warn('Journium: Failed to save config to cache:', error);
         }
     }
     initializeSync() {
         // Step 1: Load cached remote options from localStorage (synchronous)
         const cachedRemoteOptions = this.loadCachedOptions();
-        // Step 2: If no local options provided, use cached remote options
-        if (!this.config.options && cachedRemoteOptions) {
-            this.effectiveOptions = cachedRemoteOptions;
-            if (this.effectiveOptions.debug) {
-                console.log('Journium: Using cached remote options:', cachedRemoteOptions);
+        // Step 2: Merge cached remote options with local options (if cached options exist)
+        // Local options take precedence over cached remote options
+        if (cachedRemoteOptions) {
+            if (this.config.options) {
+                // Merge: local options override cached remote options
+                this.effectiveOptions = mergeOptions(cachedRemoteOptions, this.config.options);
+                Logger.log('Journium: Using cached remote options merged with local options:', this.effectiveOptions);
+            }
+            else {
+                // No local options, use cached remote options as-is
+                this.effectiveOptions = cachedRemoteOptions;
+                Logger.log('Journium: Using cached remote options:', cachedRemoteOptions);
             }
         }
+        // If no cached options, effectiveOptions already has defaults merged with local options from constructor
         // Step 3: Mark as initialized immediately - no need to wait for remote fetch
         this.initialized = true;
         // Step 4: Start flush timer immediately
         if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
             this.startFlushTimer();
         }
-        if (this.effectiveOptions.debug) {
-            console.log('Journium: Client initialized with effective options:', this.effectiveOptions);
-        }
+        Logger.log('Journium: Client initialized with effective options:', this.effectiveOptions);
     }
     async fetchRemoteOptionsAsync() {
         // Fetch fresh config in background
@@ -759,10 +794,9 @@ class JourniumClient {
         }
     }
     async fetchAndCacheRemoteOptions() {
+        var _a;
         try {
-            if (this.effectiveOptions.debug) {
-                console.log('Journium: Fetching remote configuration in background...');
-            }
+            Logger.log('Journium: Fetching remote configuration in background...');
             const remoteOptionsResponse = await fetchRemoteOptions(this.config.apiHost, this.config.publishableKey);
             if (remoteOptionsResponse && remoteOptionsResponse.success) {
                 // Save remote config to cache for next session
@@ -780,18 +814,38 @@ class JourniumClient {
                 if (this.effectiveOptions.sessionTimeout) {
                     this.identityManager.updateSessionTimeout(this.effectiveOptions.sessionTimeout);
                 }
-                if (this.effectiveOptions.debug) {
-                    console.log('Journium: Background remote options applied:', remoteOptionsResponse.config);
-                    console.log('Journium: New effective options:', this.effectiveOptions);
-                }
+                Logger.log('Journium: Background remote options applied:', remoteOptionsResponse.config);
+                Logger.log('Journium: New effective options:', this.effectiveOptions);
+                // Update Logger debug setting with new options
+                Logger.setDebug((_a = this.effectiveOptions.debug) !== null && _a !== void 0 ? _a : false);
+                // Notify all registered callbacks about the options change
+                this.notifyOptionsChange();
             }
         }
         catch (error) {
-            if (this.effectiveOptions.debug) {
-                console.warn('Journium: Background remote options fetch failed:', error);
-            }
+            Logger.warn('Journium: Background remote options fetch failed:', error);
         }
     }
+    /**
+     * Register a callback to be notified when effective options change (e.g., when remote options are fetched)
+     */
+    onOptionsChange(callback) {
+        this.optionsChangeCallbacks.add(callback);
+        // Return unsubscribe function
+        return () => {
+            this.optionsChangeCallbacks.delete(callback);
+        };
+    }
+    notifyOptionsChange() {
+        this.optionsChangeCallbacks.forEach(callback => {
+            try {
+                callback(this.effectiveOptions);
+            }
+            catch (error) {
+                Logger.warn('Journium: Error in options change callback:', error);
+            }
+        });
+    }
     startFlushTimer() {
         if (this.flushTimer) {
             clearInterval(this.flushTimer);
@@ -818,24 +872,17 @@ class JourniumClient {
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            if (this.effectiveOptions.debug) {
-                console.log('Journium: Successfully sent events', events);
-            }
+            Logger.log('Journium: Successfully sent events', events);
         }
         catch (error) {
-            if (this.effectiveOptions.debug) {
-                console.error('Journium: Failed to send events', error);
-            }
+            Logger.error('Journium: Failed to send events', error);
             throw error;
         }
     }
     identify(distinctId, attributes = {}) {
-        var _a;
         // Don't identify if SDK is not properly configured
         if (!this.config || !this.config.publishableKey || !this.initialized) {
-            if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
-                console.warn('Journium: identify() call rejected - SDK not ready');
-            }
+            Logger.warn('Journium: identify() call rejected - SDK not ready');
             return;
         }
         // Call identify on identity manager to get previous distinct ID
@@ -846,32 +893,22 @@ class JourniumClient {
             $anon_distinct_id: previousDistinctId,
         };
         this.track('$identify', identifyProperties);
-        if (this.effectiveOptions.debug) {
-            console.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
-        }
+        Logger.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
     }
     reset() {
-        var _a;
         // Don't reset if SDK is not properly configured
         if (!this.config || !this.config.publishableKey || !this.initialized) {
-            if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
-                console.warn('Journium: reset() call rejected - SDK not ready');
-            }
+            Logger.warn('Journium: reset() call rejected - SDK not ready');
             return;
         }
         // Reset identity in identity manager
         this.identityManager.reset();
-        if (this.effectiveOptions.debug) {
-            console.log('Journium: User identity reset');
-        }
+        Logger.log('Journium: User identity reset');
     }
     track(event, properties = {}) {
-        var _a;
         // Don't track if SDK is not properly configured
         if (!this.config || !this.config.publishableKey || !this.initialized) {
-            if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
-                console.warn('Journium: track() call rejected - SDK not ready');
-            }
+            Logger.warn('Journium: track() call rejected - SDK not ready');
             return;
         }
         const identity = this.identityManager.getIdentity();
@@ -897,9 +934,7 @@ class JourniumClient {
             properties: eventProperties,
         };
         this.queue.push(journiumEvent);
-        if (this.effectiveOptions.debug) {
-            console.log('Journium: Event tracked', journiumEvent);
-        }
+        Logger.log('Journium: Event tracked', journiumEvent);
         if (this.queue.length >= this.effectiveOptions.flushAt) {
             this.flush();
         }
@@ -1022,6 +1057,31 @@ class AutocaptureTracker {
             ...options,
         };
     }
+    /**
+     * Update autocapture options and restart if currently active
+     */
+    updateOptions(options) {
+        const wasActive = this.isActive;
+        // Stop if currently active
+        if (wasActive) {
+            this.stop();
+        }
+        // Update options
+        this.options = {
+            captureClicks: true,
+            captureFormSubmits: true,
+            captureFormChanges: true,
+            captureTextSelection: false,
+            ignoreClasses: ['journium-ignore'],
+            ignoreElements: ['script', 'style', 'noscript'],
+            captureContentText: true,
+            ...options,
+        };
+        // Restart if it was active before
+        if (wasActive) {
+            this.start();
+        }
+    }
     start() {
         if (!isBrowser() || this.isActive) {
             return;
@@ -1351,14 +1411,19 @@ class AutocaptureTracker {
 
 class JourniumAnalytics {
     constructor(config) {
-        var _a, _b;
+        this.autocaptureStarted = false;
         this.config = config;
         this.client = new JourniumClient(config);
         this.pageviewTracker = new PageviewTracker(this.client);
-        const autocaptureOptions = this.resolveAutocaptureOptions((_a = config.options) === null || _a === void 0 ? void 0 : _a.autocapture);
-        this.autocaptureTracker = new AutocaptureTracker(this.client, autocaptureOptions);
-        // Store resolved autocapture state for startAutocapture method
-        this.autocaptureEnabled = ((_b = config.options) === null || _b === void 0 ? void 0 : _b.autocapture) !== false;
+        // Initialize autocapture tracker with effective options (may include cached remote options)
+        // This ensures we use the correct initial state even if cached remote options exist
+        const initialEffectiveOptions = this.client.getEffectiveOptions();
+        const initialAutocaptureOptions = this.resolveAutocaptureOptions(initialEffectiveOptions.autocapture);
+        this.autocaptureTracker = new AutocaptureTracker(this.client, initialAutocaptureOptions);
+        // Listen for options changes (e.g., when fresh remote options are fetched)
+        this.unsubscribeOptionsChange = this.client.onOptionsChange((effectiveOptions) => {
+            this.handleOptionsChange(effectiveOptions);
+        });
     }
     resolveAutocaptureOptions(autocapture) {
         if (autocapture === false) {
@@ -1387,19 +1452,51 @@ class JourniumAnalytics {
         this.pageviewTracker.capturePageview(properties);
     }
     startAutocapture() {
-        // Check if automatic pageview tracking is enabled (defaults to true)
+        // Always check effective options (which may include remote options)
         const effectiveOptions = this.client.getEffectiveOptions();
         const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+        const autocaptureEnabled = effectiveOptions.autocapture !== false;
+        // Update autocapture tracker options if they've changed
+        const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
+        this.autocaptureTracker.updateOptions(autocaptureOptions);
         if (autoTrackPageviews) {
             this.pageviewTracker.startAutocapture();
         }
-        if (this.autocaptureEnabled) {
+        if (autocaptureEnabled) {
             this.autocaptureTracker.start();
         }
+        this.autocaptureStarted = true;
     }
     stopAutocapture() {
         this.pageviewTracker.stopAutocapture();
         this.autocaptureTracker.stop();
+        this.autocaptureStarted = false;
+    }
+    /**
+     * Handle effective options change (e.g., when remote options are fetched)
+     */
+    handleOptionsChange(effectiveOptions) {
+        // If autocapture was already started, re-evaluate with new options
+        if (this.autocaptureStarted) {
+            // Stop current autocapture
+            this.pageviewTracker.stopAutocapture();
+            this.autocaptureTracker.stop();
+            this.autocaptureStarted = false;
+            // Re-evaluate if autocapture should be enabled with new options
+            const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+            const autocaptureEnabled = effectiveOptions.autocapture !== false;
+            // Update autocapture tracker options
+            const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
+            this.autocaptureTracker.updateOptions(autocaptureOptions);
+            // Restart only if still enabled
+            if (autoTrackPageviews) {
+                this.pageviewTracker.startAutocapture();
+            }
+            if (autocaptureEnabled) {
+                this.autocaptureTracker.start();
+            }
+            this.autocaptureStarted = autoTrackPageviews || autocaptureEnabled;
+        }
     }
     async flush() {
         return this.client.flush();
@@ -1407,9 +1504,18 @@ class JourniumAnalytics {
     getEffectiveOptions() {
         return this.client.getEffectiveOptions();
     }
+    /**
+     * Register a callback to be notified when effective options change
+     */
+    onOptionsChange(callback) {
+        return this.client.onOptionsChange(callback);
+    }
     destroy() {
         this.pageviewTracker.stopAutocapture();
         this.autocaptureTracker.stop();
+        if (this.unsubscribeOptionsChange) {
+            this.unsubscribeOptionsChange();
+        }
         this.client.destroy();
     }
 }
@@ -1423,15 +1529,25 @@ const JourniumProvider = ({ children, config, }) => {
     const [effectiveOptions, setEffectiveOptions] = useState(null);
     useEffect(() => {
         const analyticsInstance = new JourniumAnalytics(config);
-        // Get effective options and check if autocapture is enabled
-        const effective = analyticsInstance.getEffectiveOptions();
-        setEffectiveOptions(effective);
-        const autocaptureEnabled = effective.autocapture !== false;
+        // Get initial effective options (may include cached remote options)
+        const initialEffective = analyticsInstance.getEffectiveOptions();
+        setEffectiveOptions(initialEffective);
+        // Check if autocapture should be enabled based on initial effective options
+        const autocaptureEnabled = initialEffective.autocapture !== false;
         if (autocaptureEnabled) {
             analyticsInstance.startAutocapture();
         }
         setAnalytics(analyticsInstance);
+        // Listen for options changes (when remote options are fetched)
+        // Note: JourniumAnalytics already handles restarting autocapture when options change
+        // We just need to update the effectiveOptions state for consumers
+        const unsubscribe = analyticsInstance.onOptionsChange((newOptions) => {
+            setEffectiveOptions(newOptions);
+        });
         return () => {
+            if (unsubscribe) {
+                unsubscribe();
+            }
             analyticsInstance.destroy();
             setAnalytics(null);
             setEffectiveOptions(null);
@@ -1500,5 +1616,5 @@ const useAutocapture = () => {
     return { startAutocapture, stopAutocapture };
 };
 
-export { AutocaptureTracker, BrowserIdentityManager, JourniumAnalytics, JourniumClient, JourniumProvider, PageviewTracker, fetchRemoteOptions, generateId, generateUuidv7, getCurrentTimestamp, getCurrentUrl, getPageTitle, getReferrer, init, isBrowser, isNode, mergeOptions, useAutoTrackPageview, useAutocapture, useIdentify, useJournium, useReset, useTrackEvent, useTrackPageview };
+export { AutocaptureTracker, BrowserIdentityManager, JourniumAnalytics, JourniumClient, JourniumProvider, Logger, PageviewTracker, fetchRemoteOptions, generateId, generateUuidv7, getCurrentTimestamp, getCurrentUrl, getPageTitle, getReferrer, init, isBrowser, isNode, mergeOptions, useAutoTrackPageview, useAutocapture, useIdentify, useJournium, useReset, useTrackEvent, useTrackPageview };
 //# sourceMappingURL=index.mjs.map