@journium/js 1.1.0 → 1.2.0

package/dist/index.umd.js

@@ -1,7 +1,7 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JourniumAnalytics = {}));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.journium = {}));
 })(this, (function (exports) { 'use strict';
 
     /**
@@ -452,9 +452,9 @@
                     'Content-Type': 'application/json',
                 },
             });
-            if (!response.ok) {
-                throw new Error(`Options fetch failed: ${response.status} ${response.statusText}`);
-            }
+            // if (!response.ok) {
+            //   throw new Error(`Options fetch failed: ${response.status} ${response.statusText}`);
+            // }
             const data = await response.json();
             return data;
         }
@@ -707,20 +707,19 @@
             this.queue = [];
             this.stagedEvents = [];
             this.flushTimer = null;
+            this.remoteOptionsRefreshTimer = null;
+            this.isRefreshing = false;
+            this.lastRemoteOptions = null;
             this.initializationComplete = false;
             this.initializationFailed = false;
-            this.disabled = false;
             this.optionsChangeCallbacks = new Set();
-            // Validate required configuration - put in disabled state if invalid
+            // Validate required configuration
             if (!config.publishableKey || config.publishableKey.trim() === '') {
-                this.disabled = true;
+                // Reject initialization with clear error
+                const errorMsg = 'Journium: publishableKey is required but not provided or is empty. SDK cannot be initialized.';
                 Logger.setDebug(true);
-                Logger.error('Journium: publishableKey is required but not provided or is empty. SDK will not function.');
-                // Create minimal config to prevent crashes
-                this.config = { publishableKey: '', apiHost: 'https://events.journium.app' };
-                this.effectiveOptions = { debug: true };
-                this.optionsStorageKey = 'jrnm_invalid_options';
-                return;
+                Logger.error(errorMsg);
+                throw new Error(errorMsg);
             }
             // Set default apiHost if not provided
             this.config = {
@@ -764,62 +763,24 @@
             }
         }
         async initializeAsync() {
-            var _a;
             try {
                 Logger.log('Journium: Starting initialization - fetching fresh remote config...');
-                // Step 1: Try to fetch fresh remote config with timeout and retry
                 const remoteOptions = await this.fetchRemoteOptionsWithRetry();
-                if (remoteOptions) {
-                    // Step 2: Cache the fresh remote config
-                    this.saveCachedOptions(remoteOptions);
-                    // Step 3: Merge local options over remote config (local overrides remote)
-                    if (this.config.options) {
-                        this.effectiveOptions = mergeOptions(this.config.options, remoteOptions);
-                        Logger.log('Journium: Using fresh remote config merged with local options:', this.effectiveOptions);
-                    }
-                    else {
-                        this.effectiveOptions = remoteOptions;
-                        Logger.log('Journium: Using fresh remote config:', this.effectiveOptions);
-                    }
-                }
-                else {
-                    // Step 4: Fallback to cached config if fresh fetch failed
-                    const cachedRemoteOptions = this.loadCachedOptions();
-                    if (cachedRemoteOptions) {
-                        if (this.config.options) {
-                            this.effectiveOptions = mergeOptions(this.config.options, cachedRemoteOptions);
-                            Logger.log('Journium: Fresh config failed, using cached remote config merged with local options:', this.effectiveOptions);
-                        }
-                        else {
-                            this.effectiveOptions = cachedRemoteOptions;
-                            Logger.log('Journium: Fresh config failed, using cached remote config:', this.effectiveOptions);
-                        }
-                    }
-                    else {
-                        // Step 5: No remote config and no cached config - initialization fails
-                        Logger.error('Journium: Initialization failed - no remote config available and no cached config found');
-                        this.initializationFailed = true;
-                        this.initializationComplete = false;
-                        return;
-                    }
-                }
-                // Step 6: Update identity manager session timeout if provided
-                if (this.effectiveOptions.sessionTimeout) {
-                    this.identityManager.updateSessionTimeout(this.effectiveOptions.sessionTimeout);
+                if (!remoteOptions) {
+                    Logger.error('Journium: Initialization failed - no remote config available');
+                    this.initializationFailed = true;
+                    return;
                 }
-                // Step 7: Update Logger debug setting
-                Logger.setDebug((_a = this.effectiveOptions.debug) !== null && _a !== void 0 ? _a : false);
-                // Step 8: Mark initialization as complete
+                this.applyRemoteOptions(remoteOptions);
+                Logger.log('Journium: Effective options after init:', this.effectiveOptions);
                 this.initializationComplete = true;
                 this.initializationFailed = false;
-                // Step 9: Process any staged events
                 this.processStagedEvents();
-                // Step 10: Start flush timer
                 if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
                     this.startFlushTimer();
                 }
-                Logger.log('Journium: Initialization complete with options:', this.effectiveOptions);
-                // Step 11: Notify callbacks about options
+                this.startRemoteOptionsRefreshTimer();
+                Logger.log('Journium: Initialization complete');
                 this.notifyOptionsChange();
             }
             catch (error) {
@@ -841,11 +802,15 @@
                     // Race fetch against timeout
                     const fetchPromise = fetchRemoteOptions(this.config.apiHost, this.config.publishableKey);
                     const remoteOptionsResponse = await Promise.race([fetchPromise, timeoutPromise]);
-                    if (remoteOptionsResponse && remoteOptionsResponse.success) {
+                    if (remoteOptionsResponse && remoteOptionsResponse.status === 'success') {
                         Logger.log('Journium: Successfully fetched fresh remote config:', remoteOptionsResponse.config);
-                        return remoteOptionsResponse.config;
+                        return remoteOptionsResponse.config || null;
                     }
-                    else {
+                    else if (remoteOptionsResponse && remoteOptionsResponse.status === 'error' && remoteOptionsResponse.errorCode === 'J_ERR_TENANT_NOT_FOUND') {
+                        Logger.error('Journium: Invalid publishableKey is being used.');
+                        return null;
+                    }
+                    {
                         throw new Error('Remote config fetch unsuccessful');
                     }
                 }
@@ -886,35 +851,21 @@
         processStagedEvents() {
             if (this.stagedEvents.length === 0)
                 return;
+            if (this.ingestionPaused) {
+                Logger.warn(`Journium: Ingestion is paused — discarding ${this.stagedEvents.length} staged events`);
+                this.stagedEvents = [];
+                return;
+            }
             Logger.log(`Journium: Processing ${this.stagedEvents.length} staged events`);
-            // Move staged events to main queue, adding identity properties now
-            const identity = this.identityManager.getIdentity();
-            const userAgentInfo = this.identityManager.getUserAgentInfo();
             for (const stagedEvent of this.stagedEvents) {
-                // Add identity properties that weren't available during staging
-                const eventWithIdentity = {
+                this.queue.push({
                     ...stagedEvent,
-                    properties: {
-                        $device_id: identity === null || identity === void 0 ? void 0 : identity.$device_id,
-                        distinct_id: identity === null || identity === void 0 ? void 0 : identity.distinct_id,
-                        $session_id: identity === null || identity === void 0 ? void 0 : identity.$session_id,
-                        $is_identified: (identity === null || identity === void 0 ? void 0 : identity.$user_state) === 'identified',
-                        $current_url: typeof window !== 'undefined' ? window.location.href : '',
-                        $pathname: typeof window !== 'undefined' ? window.location.pathname : '',
-                        ...userAgentInfo,
-                        $lib_version: '0.1.0', // TODO: Get from package.json
-                        $platform: 'web',
-                        ...stagedEvent.properties, // Original properties override system properties
-                    },
-                };
-                this.queue.push(eventWithIdentity);
+                    properties: this.buildIdentityProperties(stagedEvent.properties),
+                });
             }
-            // Clear staged events
             this.stagedEvents = [];
             Logger.log('Journium: Staged events processed and moved to main queue');
-            // Check if we should flush immediately
             if (this.queue.length >= this.effectiveOptions.flushAt) {
-                // console.log('1 Journium: Flushing events...'+JSON.stringify(this.effectiveOptions));
                 this.flush();
             }
         }
@@ -922,12 +873,88 @@
             if (this.flushTimer) {
                 clearInterval(this.flushTimer);
             }
-            // Use universal setInterval (works in both browser and Node.js)
             this.flushTimer = setInterval(() => {
-                // console.log('2 Journium: Flushing events...'+JSON.stringify(this.effectiveOptions));
                 this.flush();
             }, this.effectiveOptions.flushInterval);
         }
+        startRemoteOptionsRefreshTimer() {
+            // Clear any existing timer to prevent duplicate intervals
+            if (this.remoteOptionsRefreshTimer) {
+                clearInterval(this.remoteOptionsRefreshTimer);
+                this.remoteOptionsRefreshTimer = null;
+            }
+            this.remoteOptionsRefreshTimer = setInterval(() => {
+                this.refreshRemoteOptions();
+            }, JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL);
+            Logger.log(`Journium: Scheduling remote options refresh every ${JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL}ms`);
+        }
+        async refreshRemoteOptions() {
+            if (this.isRefreshing) {
+                Logger.log('Journium: Remote options refresh already in progress, skipping');
+                return;
+            }
+            this.isRefreshing = true;
+            Logger.log('Journium: Periodic remote options refresh triggered');
+            try {
+                const remoteOptions = await this.fetchRemoteOptionsWithRetry();
+                if (!remoteOptions) {
+                    Logger.warn('Journium: Periodic remote options refresh failed, keeping current options');
+                    return;
+                }
+                const prevRemoteSnapshot = JSON.stringify(this.lastRemoteOptions);
+                const prevFlushInterval = this.effectiveOptions.flushInterval;
+                this.applyRemoteOptions(remoteOptions);
+                if (prevRemoteSnapshot === JSON.stringify(this.lastRemoteOptions)) {
+                    Logger.log('Journium: Remote options unchanged after refresh, no update needed');
+                    return;
+                }
+                Logger.log('Journium: Remote options updated after refresh:', this.effectiveOptions);
+                if (this.effectiveOptions.flushInterval !== prevFlushInterval) {
+                    if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
+                        this.startFlushTimer();
+                    }
+                    else if (this.flushTimer) {
+                        clearInterval(this.flushTimer);
+                        this.flushTimer = null;
+                    }
+                }
+                this.notifyOptionsChange();
+            }
+            catch (error) {
+                Logger.error('Journium: Periodic remote options refresh encountered an error:', error);
+            }
+            finally {
+                this.isRefreshing = false;
+            }
+        }
+        applyRemoteOptions(remoteOptions) {
+            var _a;
+            this.lastRemoteOptions = remoteOptions;
+            this.effectiveOptions = this.config.options
+                ? mergeOptions(this.config.options, remoteOptions)
+                : remoteOptions;
+            this.saveCachedOptions(remoteOptions);
+            if (this.effectiveOptions.sessionTimeout) {
+                this.identityManager.updateSessionTimeout(this.effectiveOptions.sessionTimeout);
+            }
+            Logger.setDebug((_a = this.effectiveOptions.debug) !== null && _a !== void 0 ? _a : false);
+        }
+        buildIdentityProperties(userProperties = {}) {
+            const identity = this.identityManager.getIdentity();
+            const userAgentInfo = this.identityManager.getUserAgentInfo();
+            return {
+                $device_id: identity === null || identity === void 0 ? void 0 : identity.$device_id,
+                distinct_id: identity === null || identity === void 0 ? void 0 : identity.distinct_id,
+                $session_id: identity === null || identity === void 0 ? void 0 : identity.$session_id,
+                $is_identified: (identity === null || identity === void 0 ? void 0 : identity.$user_state) === 'identified',
+                $current_url: typeof window !== 'undefined' ? window.location.href : '',
+                $pathname: typeof window !== 'undefined' ? window.location.pathname : '',
+                ...userAgentInfo,
+                $lib_version: '0.1.0', // TODO: Get from package.json
+                $platform: 'web',
+                ...userProperties,
+            };
+        }
         async sendEvents(events) {
             if (!events.length)
                 return;
@@ -953,11 +980,6 @@
             }
         }
         identify(distinctId, attributes = {}) {
-            // Don't identify if SDK is not properly configured or disabled
-            if (this.disabled || !this.config || !this.config.publishableKey) {
-                Logger.warn('Journium: identify() call rejected - SDK not ready or disabled');
-                return;
-            }
             // Don't identify if initialization failed
             if (this.initializationFailed) {
                 Logger.warn('Journium: identify() call rejected - initialization failed');
@@ -974,11 +996,6 @@
             Logger.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
         }
         reset() {
-            // Don't reset if SDK is not properly configured or disabled
-            if (this.disabled || !this.config || !this.config.publishableKey) {
-                Logger.warn('Journium: reset() call rejected - SDK not ready or disabled');
-                return;
-            }
             // Don't reset if initialization failed
             if (this.initializationFailed) {
                 Logger.warn('Journium: reset() call rejected - initialization failed');
@@ -989,11 +1006,6 @@
             Logger.log('Journium: User identity reset');
         }
         track(event, properties = {}) {
-            // Don't track if SDK is not properly configured or disabled
-            if (this.disabled || !this.config || !this.config.publishableKey) {
-                Logger.warn('Journium: track() call rejected - SDK not ready or disabled');
-                return;
-            }
             // Create minimal event without identity properties (will be added later if staging)
             const journiumEvent = {
                 uuid: generateUuidv7(),
@@ -1002,9 +1014,7 @@
                 event,
                 properties: { ...properties }, // Only user properties for now
             };
-            // Stage events during initialization, add to queue after initialization
             if (!this.initializationComplete) {
-                // If initialization failed, reject events
                 if (this.initializationFailed) {
                     Logger.warn('Journium: track() call rejected - initialization failed');
                     return;
@@ -1013,42 +1023,21 @@
                 Logger.log('Journium: Event staged during initialization', journiumEvent);
                 return;
             }
-            // If initialization failed, reject events
-            if (this.initializationFailed) {
-                Logger.warn('Journium: track() call rejected - initialization failed');
+            if (this.ingestionPaused) {
+                Logger.warn('Journium: Ingestion is paused — event dropped:', journiumEvent.event);
                 return;
             }
-            // Add identity properties for immediate events (after initialization)
-            const identity = this.identityManager.getIdentity();
-            const userAgentInfo = this.identityManager.getUserAgentInfo();
             const eventWithIdentity = {
                 ...journiumEvent,
-                properties: {
-                    $device_id: identity === null || identity === void 0 ? void 0 : identity.$device_id,
-                    distinct_id: identity === null || identity === void 0 ? void 0 : identity.distinct_id,
-                    $session_id: identity === null || identity === void 0 ? void 0 : identity.$session_id,
-                    $is_identified: (identity === null || identity === void 0 ? void 0 : identity.$user_state) === 'identified',
-                    $current_url: typeof window !== 'undefined' ? window.location.href : '',
-                    $pathname: typeof window !== 'undefined' ? window.location.pathname : '',
-                    ...userAgentInfo,
-                    $lib_version: '0.1.0', // TODO: Get from package.json
-                    $platform: 'web',
-                    ...properties, // User-provided properties override system properties
-                },
+                properties: this.buildIdentityProperties(properties),
             };
             this.queue.push(eventWithIdentity);
             Logger.log('Journium: Event tracked', eventWithIdentity);
-            // Only flush if we have effective options (after initialization)
             if (this.effectiveOptions.flushAt && this.queue.length >= this.effectiveOptions.flushAt) {
-                // console.log('3 Journium: Flushing events...'+JSON.stringify(this.effectiveOptions));
                 this.flush();
             }
         }
         async flush() {
-            // Don't flush if SDK is not properly configured
-            if (!this.config || !this.config.publishableKey) {
-                return;
-            }
             // Don't flush if initialization failed
             if (this.initializationFailed) {
                 Logger.warn('Journium: flush() call rejected - initialization failed');
@@ -1071,12 +1060,20 @@
                 clearInterval(this.flushTimer);
                 this.flushTimer = null;
             }
+            if (this.remoteOptionsRefreshTimer) {
+                clearInterval(this.remoteOptionsRefreshTimer);
+                this.remoteOptionsRefreshTimer = null;
+            }
             this.flush();
         }
         getEffectiveOptions() {
             return this.effectiveOptions;
         }
+        get ingestionPaused() {
+            return this.effectiveOptions['ingestionPaused'] === true;
+        }
     }
+    JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL = 15 * 60 * 1000; // 15 minutes
 
     class PageviewTracker {
         constructor(client) {
@@ -1103,10 +1100,13 @@
         }
         /**
          * Start automatic autocapture for pageviews
-         * @returns void
+         * @param captureInitialPageview - whether to fire a $pageview immediately on start (default: true).
+         *   Pass false when restarting after a remote options update to avoid a spurious pageview.
          */
-        startAutoPageviewTracking() {
-            this.capturePageview();
+        startAutoPageviewTracking(captureInitialPageview = true) {
+            if (captureInitialPageview) {
+                this.capturePageview();
+            }
             if (typeof window !== 'undefined') {
                 // Store original methods for cleanup
                 this.originalPushState = window.history.pushState;
@@ -1625,21 +1625,22 @@
          * Handle effective options change (e.g., when remote options are fetched)
          */
         handleOptionsChange(effectiveOptions) {
-            // Stop current autocapture if it was already started
+            // If autocapture was never started before, this is the initial options application
+            // (async init completed) — treat it like a page load and capture a pageview.
+            // If it was already started, this is a periodic remote options update — only
+            // re-register listeners without emitting a spurious pageview.
+            const isFirstStart = !this.autocaptureStarted;
             if (this.autocaptureStarted) {
                 this.pageviewTracker.stopAutocapture();
                 this.autocaptureTracker.stop();
                 this.autocaptureStarted = false;
             }
-            // 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);
-            // Start autocapture based on new options (even if it wasn't started before)
             if (autoTrackPageviews) {
-                this.pageviewTracker.startAutoPageviewTracking();
+                this.pageviewTracker.startAutoPageviewTracking(isFirstStart);
             }
             if (autocaptureEnabled) {
                 this.autocaptureTracker.start();
@@ -1673,7 +1674,6 @@
 
     exports.AutocaptureTracker = AutocaptureTracker;
     exports.BrowserIdentityManager = BrowserIdentityManager;
-    exports.JourniumAnalytics = JourniumAnalytics;
     exports.JourniumClient = JourniumClient;
     exports.Logger = Logger;
     exports.PageviewTracker = PageviewTracker;