@journium/react 1.0.6 → 1.0.7

package/dist/index.mjs

@@ -703,6 +703,7 @@ class JourniumClient {
         this.queue = [];
         this.flushTimer = null;
         this.initialized = false;
+        this.optionsChangeCallbacks = new Set();
         // Validate required configuration
         if (!config.publishableKey) {
             Logger.setDebug(true);
@@ -763,11 +764,21 @@ class JourniumClient {
     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;
-            Logger.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
@@ -807,12 +818,34 @@ class JourniumClient {
                 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) {
             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);
@@ -1024,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;
@@ -1353,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) {
@@ -1389,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();
@@ -1409,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();
     }
 }
@@ -1425,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);