@journium/js 1.0.0 → 1.0.1

package/dist/index.umd.js

@@ -431,9 +431,9 @@
         var _a;
         return typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
     };
-    const fetchRemoteConfig = async (apiHost, token, fetchFn) => {
+    const fetchRemoteConfig = async (apiHost, publishableKey, fetchFn) => {
         const endpoint = '/v1/configs';
-        const url = `${apiHost}${endpoint}?ingestion_key=${encodeURIComponent(token)}`;
+        const url = `${apiHost}${endpoint}?ingestion_key=${encodeURIComponent(publishableKey)}`;
         try {
             let fetch = fetchFn;
             if (!fetch) {
@@ -464,25 +464,31 @@
         }
     };
     const mergeConfigs = (localConfig, remoteConfig) => {
+        if (!remoteConfig && !localConfig) {
+            return {};
+        }
         if (!remoteConfig) {
             return localConfig;
         }
-        // Deep merge remote config into local config
-        // Remote config takes precedence over local config
-        const merged = { ...localConfig };
+        if (!localConfig) {
+            return remoteConfig;
+        }
+        // Deep merge local config into remote config
+        // Local config takes precedence over remote config
+        const merged = { ...remoteConfig };
         // Handle primitive values
-        Object.keys(remoteConfig).forEach(key => {
-            if (remoteConfig[key] !== undefined && remoteConfig[key] !== null) {
-                if (typeof remoteConfig[key] === 'object' && !Array.isArray(remoteConfig[key])) {
-                    // Deep merge objects
+        Object.keys(localConfig).forEach(key => {
+            if (localConfig[key] !== undefined && localConfig[key] !== null) {
+                if (typeof localConfig[key] === 'object' && !Array.isArray(localConfig[key])) {
+                    // Deep merge objects - local config overrides remote
                     merged[key] = {
                         ...(merged[key] || {}),
-                        ...remoteConfig[key]
+                        ...localConfig[key]
                     };
                 }
                 else {
-                    // Override primitive values and arrays
-                    merged[key] = remoteConfig[key];
+                    // Override primitive values and arrays with local config
+                    merged[key] = localConfig[key];
                 }
             }
         });
@@ -491,14 +497,14 @@
 
     const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes in ms
     class BrowserIdentityManager {
-        constructor(sessionTimeout, token) {
+        constructor(sessionTimeout, publishableKey) {
             this.identity = null;
             this.sessionTimeout = DEFAULT_SESSION_TIMEOUT;
             if (sessionTimeout) {
                 this.sessionTimeout = sessionTimeout;
             }
-            // Generate storage key with token pattern: jrnm_<token>_journium
-            this.storageKey = token ? `jrnm_${token}_journium` : '__journium_identity';
+            // Generate storage key with publishableKey pattern: jrnm_<publishableKey>_journium
+            this.storageKey = publishableKey ? `jrnm_${publishableKey}_journium` : '__journium_identity';
             this.loadOrCreateIdentity();
         }
         loadOrCreateIdentity() {
@@ -670,24 +676,37 @@
             this.flushTimer = null;
             this.initialized = false;
             // Validate required configuration
-            if (!config.token) {
-                console.error('Journium: token is required but not provided. SDK will not function.');
+            if (!config.publishableKey) {
+                console.error('Journium: publishableKey is required but not provided. SDK will not function.');
                 return;
             }
-            if (!config.apiHost) {
-                console.error('Journium: apiHost is required but not provided. SDK will not function.');
-                return;
-            }
-            this.config = config;
+            // Set default apiHost if not provided
+            this.config = {
+                ...config,
+                apiHost: config.apiHost || 'https://events.journium.app'
+            };
             // Generate storage key for config caching
-            this.configStorageKey = `jrnm_${config.token}_config`;
+            this.configStorageKey = `jrnm_${config.publishableKey}_config`;
+            // Generate default values
+            const defaultConfig = {
+                debug: false,
+                flushAt: 20,
+                flushInterval: 10000,
+                sessionTimeout: 30 * 60 * 1000, // 30 minutes
+            };
+            // Initialize effective config with local config taking precedence over defaults
+            this.effectiveConfig = { ...defaultConfig };
+            if (this.config.config) {
+                this.effectiveConfig = mergeConfigs(this.config.config, defaultConfig);
+            }
             // Initialize identity manager
-            this.identityManager = new BrowserIdentityManager(this.config.sessionTimeout, this.config.token);
+            this.identityManager = new BrowserIdentityManager(this.effectiveConfig.sessionTimeout, this.config.publishableKey);
             // Initialize synchronously with cached config, fetch fresh config in background
             this.initializeSync();
             this.fetchRemoteConfigAsync();
         }
         loadCachedConfig() {
+            var _a;
             if (typeof window === 'undefined' || !window.localStorage) {
                 return null;
             }
@@ -696,13 +715,14 @@
                 return cached ? JSON.parse(cached) : null;
             }
             catch (error) {
-                if (this.config.debug) {
+                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: Failed to load cached config:', error);
                 }
                 return null;
             }
         }
         saveCachedConfig(config) {
+            var _a;
             if (typeof window === 'undefined' || !window.localStorage) {
                 return;
             }
@@ -710,91 +730,67 @@
                 window.localStorage.setItem(this.configStorageKey, JSON.stringify(config));
             }
             catch (error) {
-                if (this.config.debug) {
+                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: Failed to save config to cache:', error);
                 }
             }
         }
         initializeSync() {
-            var _a, _b, _c;
-            // Step 1: Load cached config from localStorage (synchronous)
-            const cachedConfig = this.loadCachedConfig();
-            // Step 2: Apply cached config immediately, or use defaults
-            const localOnlyConfig = {
-                apiHost: this.config.apiHost,
-                token: this.config.token,
-            };
-            if (cachedConfig) {
-                // Use cached remote config
-                this.config = {
-                    ...localOnlyConfig,
-                    ...cachedConfig,
-                };
-                if (this.config.debug) {
-                    console.log('Journium: Using cached configuration:', cachedConfig);
-                }
-            }
-            else {
-                // Use defaults for first-time initialization
-                this.config = {
-                    ...this.config,
-                    debug: (_a = this.config.debug) !== null && _a !== void 0 ? _a : false,
-                    flushAt: (_b = this.config.flushAt) !== null && _b !== void 0 ? _b : 20,
-                    flushInterval: (_c = this.config.flushInterval) !== null && _c !== void 0 ? _c : 10000,
-                };
-                if (this.config.debug) {
-                    console.log('Journium: No cached config found, using defaults');
+            // Step 1: Load cached remote config from localStorage (synchronous)
+            const cachedRemoteConfig = this.loadCachedConfig();
+            // Step 2: If no local config provided, use cached remote config
+            if (!this.config.config && cachedRemoteConfig) {
+                this.effectiveConfig = mergeConfigs(undefined, cachedRemoteConfig);
+                if (this.effectiveConfig.debug) {
+                    console.log('Journium: Using cached remote configuration:', cachedRemoteConfig);
                 }
             }
-            // Update session timeout from config
-            if (this.config.sessionTimeout) {
-                this.identityManager.updateSessionTimeout(this.config.sessionTimeout);
-            }
             // Step 3: Mark as initialized immediately - no need to wait for remote fetch
             this.initialized = true;
             // Step 4: Start flush timer immediately
-            if (this.config.flushInterval && this.config.flushInterval > 0) {
+            if (this.effectiveConfig.flushInterval && this.effectiveConfig.flushInterval > 0) {
                 this.startFlushTimer();
             }
-            if (this.config.debug) {
-                console.log('Journium: Client initialized and ready to track events');
+            if (this.effectiveConfig.debug) {
+                console.log('Journium: Client initialized with effective config:', this.effectiveConfig);
             }
         }
         async fetchRemoteConfigAsync() {
             // Fetch fresh config in background
-            if (this.config.token) {
+            if (this.config.publishableKey) {
                 await this.fetchAndCacheRemoteConfig();
             }
         }
         async fetchAndCacheRemoteConfig() {
             try {
-                if (this.config.debug) {
+                if (this.effectiveConfig.debug) {
                     console.log('Journium: Fetching remote configuration in background...');
                 }
-                const remoteConfigResponse = await fetchRemoteConfig(this.config.apiHost, this.config.token);
+                const remoteConfigResponse = await fetchRemoteConfig(this.config.apiHost, this.config.publishableKey);
                 if (remoteConfigResponse && remoteConfigResponse.success) {
-                    // Save to cache for next session
+                    // Save remote config to cache for next session
                     this.saveCachedConfig(remoteConfigResponse.config);
-                    // Apply fresh config to current session
-                    const localOnlyConfig = {
-                        apiHost: this.config.apiHost,
-                        token: this.config.token,
-                    };
-                    this.config = {
-                        ...localOnlyConfig,
-                        ...remoteConfigResponse.config,
-                    };
-                    // Update session timeout if provided in fresh config
-                    if (remoteConfigResponse.config.sessionTimeout) {
-                        this.identityManager.updateSessionTimeout(remoteConfigResponse.config.sessionTimeout);
+                    // Update effective config: local config (if provided) overrides fresh remote config
+                    if (!this.config.config) {
+                        // No local config provided, use fresh remote config
+                        this.effectiveConfig = mergeConfigs(undefined, remoteConfigResponse.config);
                     }
-                    if (this.config.debug) {
+                    else {
+                        // Local config provided, merge it over fresh remote config
+                        this.effectiveConfig = mergeConfigs(this.config.config, remoteConfigResponse.config);
+                    }
+                    // Update session timeout if provided in fresh effective config
+                    if (this.effectiveConfig.sessionTimeout) {
+                        this.identityManager.updateSessionTimeout(this.effectiveConfig.sessionTimeout);
+                    }
+                    if (this.effectiveConfig.debug) {
                         console.log('Journium: Background remote configuration applied:', remoteConfigResponse.config);
+                        console.log('Journium: New effective configuration:', this.effectiveConfig);
                     }
                 }
             }
             catch (error) {
-                if (this.config.debug) {
+                if (this.effectiveConfig.debug) {
                     console.warn('Journium: Background remote config fetch failed:', error);
                 }
             }
@@ -806,7 +802,7 @@
             // Use universal setInterval (works in both browser and Node.js)
             this.flushTimer = setInterval(() => {
                 this.flush();
-            }, this.config.flushInterval);
+            }, this.effectiveConfig.flushInterval);
         }
         async sendEvents(events) {
             if (!events.length)
@@ -816,7 +812,7 @@
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.config.token}`,
+                        'Authorization': `Bearer ${this.config.publishableKey}`,
                     },
                     body: JSON.stringify({
                         events,
@@ -825,12 +821,12 @@
                 if (!response.ok) {
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                 }
-                if (this.config.debug) {
+                if (this.effectiveConfig.debug) {
                     console.log('Journium: Successfully sent events', events);
                 }
             }
             catch (error) {
-                if (this.config.debug) {
+                if (this.effectiveConfig.debug) {
                     console.error('Journium: Failed to send events', error);
                 }
                 throw error;
@@ -839,8 +835,8 @@
         identify(distinctId, attributes = {}) {
             var _a;
             // Don't identify if SDK is not properly configured
-            if (!this.config || !this.config.token || !this.config.apiHost || !this.initialized) {
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.debug) {
+            if (!this.config || !this.config.publishableKey || !this.initialized) {
+                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: identify() call rejected - SDK not ready');
                 }
                 return;
@@ -853,30 +849,30 @@
                 $anon_distinct_id: previousDistinctId,
             };
             this.track('$identify', identifyProperties);
-            if (this.config.debug) {
+            if (this.effectiveConfig.debug) {
                 console.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
             }
         }
         reset() {
             var _a;
             // Don't reset if SDK is not properly configured
-            if (!this.config || !this.config.token || !this.config.apiHost || !this.initialized) {
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.debug) {
+            if (!this.config || !this.config.publishableKey || !this.initialized) {
+                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: reset() call rejected - SDK not ready');
                 }
                 return;
             }
             // Reset identity in identity manager
             this.identityManager.reset();
-            if (this.config.debug) {
+            if (this.effectiveConfig.debug) {
                 console.log('Journium: User identity reset');
             }
         }
         track(event, properties = {}) {
             var _a;
             // Don't track if SDK is not properly configured
-            if (!this.config || !this.config.token || !this.config.apiHost || !this.initialized) {
-                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.debug) {
+            if (!this.config || !this.config.publishableKey || !this.initialized) {
+                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: track() call rejected - SDK not ready');
                 }
                 return;
@@ -898,22 +894,22 @@
             };
             const journiumEvent = {
                 uuid: generateUuidv7(),
-                ingestion_key: this.config.token,
+                ingestion_key: this.config.publishableKey,
                 client_timestamp: getCurrentTimestamp(),
                 event,
                 properties: eventProperties,
             };
             this.queue.push(journiumEvent);
-            if (this.config.debug) {
+            if (this.effectiveConfig.debug) {
                 console.log('Journium: Event tracked', journiumEvent);
             }
-            if (this.queue.length >= this.config.flushAt) {
+            if (this.queue.length >= this.effectiveConfig.flushAt) {
                 this.flush();
             }
         }
         async flush() {
             // Don't flush if SDK is not properly configured
-            if (!this.config || !this.config.token || !this.config.apiHost) {
+            if (!this.config || !this.config.publishableKey) {
                 return;
             }
             if (this.queue.length === 0)
@@ -960,7 +956,7 @@
             this.client.track('$pageview', properties);
             this.lastUrl = currentUrl;
         }
-        startAutoCapture() {
+        startAutocapture() {
             this.capturePageview();
             if (typeof window !== 'undefined') {
                 // Store original methods for cleanup
@@ -980,7 +976,7 @@
                 window.addEventListener('popstate', this.popStateHandler);
             }
         }
-        stopAutoCapture() {
+        stopAutocapture() {
             if (typeof window !== 'undefined') {
                 // Restore original methods
                 if (this.originalPushState) {
@@ -1344,13 +1340,14 @@
 
     class Journium {
         constructor(config) {
+            var _a, _b;
             this.config = config;
             this.client = new JourniumClient(config);
             this.pageviewTracker = new PageviewTracker(this.client);
-            const autocaptureConfig = this.resolveAutocaptureConfig(config.autocapture);
+            const autocaptureConfig = this.resolveAutocaptureConfig((_a = config.config) === null || _a === void 0 ? void 0 : _a.autocapture);
             this.autocaptureTracker = new AutocaptureTracker(this.client, autocaptureConfig);
-            // Store resolved autocapture state for startAutoCapture method
-            this.autocaptureEnabled = config.autocapture !== false;
+            // Store resolved autocapture state for startAutocapture method
+            this.autocaptureEnabled = ((_b = config.config) === null || _b === void 0 ? void 0 : _b.autocapture) !== false;
         }
         resolveAutocaptureConfig(autocapture) {
             if (autocapture === false) {
@@ -1378,30 +1375,21 @@
         capturePageview(properties) {
             this.pageviewTracker.capturePageview(properties);
         }
-        startAutoCapture() {
-            this.pageviewTracker.startAutoCapture();
+        startAutocapture() {
+            this.pageviewTracker.startAutocapture();
             if (this.autocaptureEnabled) {
                 this.autocaptureTracker.start();
             }
         }
-        stopAutoCapture() {
-            this.pageviewTracker.stopAutoCapture();
-            this.autocaptureTracker.stop();
-        }
-        // Aliases for consistency (deprecated - use startAutoCapture)
-        /** @deprecated Use startAutoCapture() instead */
-        startAutocapture() {
-            this.startAutoCapture();
-        }
-        /** @deprecated Use stopAutoCapture() instead */
         stopAutocapture() {
-            this.stopAutoCapture();
+            this.pageviewTracker.stopAutocapture();
+            this.autocaptureTracker.stop();
         }
         async flush() {
             return this.client.flush();
         }
         destroy() {
-            this.pageviewTracker.stopAutoCapture();
+            this.pageviewTracker.stopAutocapture();
             this.autocaptureTracker.stop();
             this.client.destroy();
         }