@journium/js 1.0.0 → 1.0.1

package/dist/index.esm.js

@@ -425,9 +425,9 @@ const isNode = () => {
     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) {
@@ -458,25 +458,31 @@ const fetchRemoteConfig = async (apiHost, token, fetchFn) => {
     }
 };
 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];
             }
         }
     });
@@ -485,14 +491,14 @@ const mergeConfigs = (localConfig, remoteConfig) => {
 
 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() {
@@ -664,24 +670,37 @@ class JourniumClient {
         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;
         }
@@ -690,13 +709,14 @@ class JourniumClient {
             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;
         }
@@ -704,91 +724,67 @@ class JourniumClient {
             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);
             }
         }
@@ -800,7 +796,7 @@ class JourniumClient {
         // 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)
@@ -810,7 +806,7 @@ class JourniumClient {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.config.token}`,
+                    'Authorization': `Bearer ${this.config.publishableKey}`,
                 },
                 body: JSON.stringify({
                     events,
@@ -819,12 +815,12 @@ class JourniumClient {
             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;
@@ -833,8 +829,8 @@ class JourniumClient {
     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;
@@ -847,30 +843,30 @@ class JourniumClient {
             $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;
@@ -892,22 +888,22 @@ class JourniumClient {
         };
         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)
@@ -954,7 +950,7 @@ class PageviewTracker {
         this.client.track('$pageview', properties);
         this.lastUrl = currentUrl;
     }
-    startAutoCapture() {
+    startAutocapture() {
         this.capturePageview();
         if (typeof window !== 'undefined') {
             // Store original methods for cleanup
@@ -974,7 +970,7 @@ class PageviewTracker {
             window.addEventListener('popstate', this.popStateHandler);
         }
     }
-    stopAutoCapture() {
+    stopAutocapture() {
         if (typeof window !== 'undefined') {
             // Restore original methods
             if (this.originalPushState) {
@@ -1338,13 +1334,14 @@ class AutocaptureTracker {
 
 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) {
@@ -1372,30 +1369,21 @@ class Journium {
     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();
     }