@journium/js 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -665,14 +665,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
@@ -694,6 +727,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
@@ -701,7 +736,6 @@ class JourniumClient {
         this.fetchRemoteOptionsAsync();
     }
     loadCachedOptions() {
-        var _a;
         if (typeof window === 'undefined' || !window.localStorage) {
             return null;
         }
@@ -710,14 +744,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;
         }
@@ -725,30 +756,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
@@ -757,10 +792,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
@@ -778,18 +812,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);
@@ -816,24 +870,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
@@ -844,32 +891,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();
@@ -895,9 +932,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();
         }
@@ -1020,6 +1055,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;
@@ -1349,14 +1409,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) {
@@ -1385,19 +1450,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();
@@ -1405,9 +1502,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();
     }
 }
@@ -1415,5 +1521,5 @@ const init = (config) => {
     return new JourniumAnalytics(config);
 };
 
-export { AutocaptureTracker, BrowserIdentityManager, JourniumAnalytics, JourniumClient, PageviewTracker, fetchRemoteOptions, generateId, generateUuidv7, getCurrentTimestamp, getCurrentUrl, getPageTitle, getReferrer, init, isBrowser, isNode, mergeOptions };
+export { AutocaptureTracker, BrowserIdentityManager, JourniumAnalytics, JourniumClient, Logger, PageviewTracker, fetchRemoteOptions, generateId, generateUuidv7, getCurrentTimestamp, getCurrentUrl, getPageTitle, getReferrer, init, isBrowser, isNode, mergeOptions };
 //# sourceMappingURL=index.mjs.map