@journium/js 1.0.1 → 1.0.3

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.Journium = {}));
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JourniumAnalytics = {}));
 })(this, (function (exports) { 'use strict';
 
     /**
@@ -431,7 +431,7 @@
         var _a;
         return typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
     };
-    const fetchRemoteConfig = async (apiHost, publishableKey, fetchFn) => {
+    const fetchRemoteOptions = async (apiHost, publishableKey, fetchFn) => {
         const endpoint = '/v1/configs';
         const url = `${apiHost}${endpoint}?ingestion_key=${encodeURIComponent(publishableKey)}`;
         try {
@@ -453,42 +453,43 @@
                 },
             });
             if (!response.ok) {
-                throw new Error(`Config fetch failed: ${response.status} ${response.statusText}`);
+                throw new Error(`Options fetch failed: ${response.status} ${response.statusText}`);
             }
             const data = await response.json();
             return data;
         }
         catch (error) {
-            console.warn('Failed to fetch remote config:', error);
+            console.warn('Failed to fetch remote options:', error);
             return null;
         }
     };
-    const mergeConfigs = (localConfig, remoteConfig) => {
-        if (!remoteConfig && !localConfig) {
+    const mergeOptions = (localOptions, remoteOptions) => {
+        if (!remoteOptions && !localOptions) {
             return {};
         }
-        if (!remoteConfig) {
-            return localConfig;
+        if (!remoteOptions) {
+            return localOptions;
         }
-        if (!localConfig) {
-            return remoteConfig;
+        if (!localOptions) {
+            return remoteOptions;
         }
-        // Deep merge local config into remote config
-        // Local config takes precedence over remote config
-        const merged = { ...remoteConfig };
+        // Deep merge local options into remote options
+        // Local options takes precedence over remote options
+        const merged = { ...remoteOptions };
         // Handle primitive values
-        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
+        Object.keys(localOptions).forEach(key => {
+            const localValue = localOptions[key];
+            if (localValue !== undefined && localValue !== null) {
+                if (typeof localValue === 'object' && !Array.isArray(localValue)) {
+                    // Deep merge objects - local options overrides remote
                     merged[key] = {
                         ...(merged[key] || {}),
-                        ...localConfig[key]
+                        ...localValue
                     };
                 }
                 else {
-                    // Override primitive values and arrays with local config
-                    merged[key] = localConfig[key];
+                    // Override primitive values and arrays with local options
+                    merged[key] = localValue;
                 }
             }
         });
@@ -592,7 +593,7 @@
             };
             this.saveIdentity();
         }
-        identify(distinctId, attributes = {}) {
+        identify(distinctId, _attributes = {}) {
             if (!this.identity)
                 return { previousDistinctId: null };
             const previousDistinctId = this.identity.distinct_id;
@@ -685,113 +686,113 @@
                 ...config,
                 apiHost: config.apiHost || 'https://events.journium.app'
             };
-            // Generate storage key for config caching
-            this.configStorageKey = `jrnm_${config.publishableKey}_config`;
+            // Generate storage key for options caching
+            this.optionsStorageKey = `jrnm_${config.publishableKey}_options`;
             // Generate default values
-            const defaultConfig = {
+            const defaultOptions = {
                 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 effective options with local options taking precedence over defaults
+            this.effectiveOptions = { ...defaultOptions };
+            if (this.config.options) {
+                this.effectiveOptions = mergeOptions(defaultOptions, this.config.options);
             }
             // Initialize identity manager
-            this.identityManager = new BrowserIdentityManager(this.effectiveConfig.sessionTimeout, this.config.publishableKey);
+            this.identityManager = new BrowserIdentityManager(this.effectiveOptions.sessionTimeout, this.config.publishableKey);
             // Initialize synchronously with cached config, fetch fresh config in background
             this.initializeSync();
-            this.fetchRemoteConfigAsync();
+            this.fetchRemoteOptionsAsync();
         }
-        loadCachedConfig() {
+        loadCachedOptions() {
             var _a;
             if (typeof window === 'undefined' || !window.localStorage) {
                 return null;
             }
             try {
-                const cached = window.localStorage.getItem(this.configStorageKey);
+                const cached = window.localStorage.getItem(this.optionsStorageKey);
                 return cached ? JSON.parse(cached) : null;
             }
             catch (error) {
-                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
+                if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: Failed to load cached config:', error);
                 }
                 return null;
             }
         }
-        saveCachedConfig(config) {
+        saveCachedOptions(options) {
             var _a;
             if (typeof window === 'undefined' || !window.localStorage) {
                 return;
             }
             try {
-                window.localStorage.setItem(this.configStorageKey, JSON.stringify(config));
+                window.localStorage.setItem(this.optionsStorageKey, JSON.stringify(options));
             }
             catch (error) {
-                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
+                if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: Failed to save config to cache:', error);
                 }
             }
         }
         initializeSync() {
-            // 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);
+            // 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 3: Mark as initialized immediately - no need to wait for remote fetch
             this.initialized = true;
             // Step 4: Start flush timer immediately
-            if (this.effectiveConfig.flushInterval && this.effectiveConfig.flushInterval > 0) {
+            if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
                 this.startFlushTimer();
             }
-            if (this.effectiveConfig.debug) {
-                console.log('Journium: Client initialized with effective config:', this.effectiveConfig);
+            if (this.effectiveOptions.debug) {
+                console.log('Journium: Client initialized with effective options:', this.effectiveOptions);
             }
         }
-        async fetchRemoteConfigAsync() {
+        async fetchRemoteOptionsAsync() {
             // Fetch fresh config in background
             if (this.config.publishableKey) {
-                await this.fetchAndCacheRemoteConfig();
+                await this.fetchAndCacheRemoteOptions();
             }
         }
-        async fetchAndCacheRemoteConfig() {
+        async fetchAndCacheRemoteOptions() {
             try {
-                if (this.effectiveConfig.debug) {
+                if (this.effectiveOptions.debug) {
                     console.log('Journium: Fetching remote configuration in background...');
                 }
-                const remoteConfigResponse = await fetchRemoteConfig(this.config.apiHost, this.config.publishableKey);
-                if (remoteConfigResponse && remoteConfigResponse.success) {
+                const remoteOptionsResponse = await fetchRemoteOptions(this.config.apiHost, this.config.publishableKey);
+                if (remoteOptionsResponse && remoteOptionsResponse.success) {
                     // Save remote config to cache for next session
-                    this.saveCachedConfig(remoteConfigResponse.config);
-                    // 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);
+                    this.saveCachedOptions(remoteOptionsResponse.config);
+                    // Update effective options: local options (if provided) overrides fresh remote options
+                    if (!this.config.options) {
+                        // No local options provided, use fresh remote options
+                        this.effectiveOptions = remoteOptionsResponse.config;
                     }
                     else {
-                        // Local config provided, merge it over fresh remote config
-                        this.effectiveConfig = mergeConfigs(this.config.config, remoteConfigResponse.config);
+                        // Local options provided, merge it over fresh remote options
+                        this.effectiveOptions = mergeOptions(remoteOptionsResponse.config, this.config.options);
                     }
-                    // Update session timeout if provided in fresh effective config
-                    if (this.effectiveConfig.sessionTimeout) {
-                        this.identityManager.updateSessionTimeout(this.effectiveConfig.sessionTimeout);
+                    // Update session timeout if provided in fresh effective options
+                    if (this.effectiveOptions.sessionTimeout) {
+                        this.identityManager.updateSessionTimeout(this.effectiveOptions.sessionTimeout);
                     }
-                    if (this.effectiveConfig.debug) {
-                        console.log('Journium: Background remote configuration applied:', remoteConfigResponse.config);
-                        console.log('Journium: New effective configuration:', this.effectiveConfig);
+                    if (this.effectiveOptions.debug) {
+                        console.log('Journium: Background remote options applied:', remoteOptionsResponse.config);
+                        console.log('Journium: New effective options:', this.effectiveOptions);
                     }
                 }
             }
             catch (error) {
-                if (this.effectiveConfig.debug) {
-                    console.warn('Journium: Background remote config fetch failed:', error);
+                if (this.effectiveOptions.debug) {
+                    console.warn('Journium: Background remote options fetch failed:', error);
                 }
             }
         }
@@ -802,7 +803,7 @@
             // Use universal setInterval (works in both browser and Node.js)
             this.flushTimer = setInterval(() => {
                 this.flush();
-            }, this.effectiveConfig.flushInterval);
+            }, this.effectiveOptions.flushInterval);
         }
         async sendEvents(events) {
             if (!events.length)
@@ -821,12 +822,12 @@
                 if (!response.ok) {
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
                 }
-                if (this.effectiveConfig.debug) {
+                if (this.effectiveOptions.debug) {
                     console.log('Journium: Successfully sent events', events);
                 }
             }
             catch (error) {
-                if (this.effectiveConfig.debug) {
+                if (this.effectiveOptions.debug) {
                     console.error('Journium: Failed to send events', error);
                 }
                 throw error;
@@ -836,7 +837,7 @@
             var _a;
             // Don't identify if SDK is not properly configured
             if (!this.config || !this.config.publishableKey || !this.initialized) {
-                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
+                if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: identify() call rejected - SDK not ready');
                 }
                 return;
@@ -849,7 +850,7 @@
                 $anon_distinct_id: previousDistinctId,
             };
             this.track('$identify', identifyProperties);
-            if (this.effectiveConfig.debug) {
+            if (this.effectiveOptions.debug) {
                 console.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
             }
         }
@@ -857,14 +858,14 @@
             var _a;
             // Don't reset if SDK is not properly configured
             if (!this.config || !this.config.publishableKey || !this.initialized) {
-                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
+                if ((_a = this.effectiveOptions) === 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.effectiveConfig.debug) {
+            if (this.effectiveOptions.debug) {
                 console.log('Journium: User identity reset');
             }
         }
@@ -872,7 +873,7 @@
             var _a;
             // Don't track if SDK is not properly configured
             if (!this.config || !this.config.publishableKey || !this.initialized) {
-                if ((_a = this.effectiveConfig) === null || _a === void 0 ? void 0 : _a.debug) {
+                if ((_a = this.effectiveOptions) === null || _a === void 0 ? void 0 : _a.debug) {
                     console.warn('Journium: track() call rejected - SDK not ready');
                 }
                 return;
@@ -900,10 +901,10 @@
                 properties: eventProperties,
             };
             this.queue.push(journiumEvent);
-            if (this.effectiveConfig.debug) {
+            if (this.effectiveOptions.debug) {
                 console.log('Journium: Event tracked', journiumEvent);
             }
-            if (this.queue.length >= this.effectiveConfig.flushAt) {
+            if (this.queue.length >= this.effectiveOptions.flushAt) {
                 this.flush();
             }
         }
@@ -931,6 +932,9 @@
             }
             this.flush();
         }
+        getEffectiveOptions() {
+            return this.effectiveOptions;
+        }
     }
 
     class PageviewTracker {
@@ -996,11 +1000,11 @@
     }
 
     class AutocaptureTracker {
-        constructor(client, config = {}) {
+        constructor(client, options = {}) {
             this.listeners = new Map();
             this.isActive = false;
             this.client = client;
-            this.config = {
+            this.options = {
                 captureClicks: true,
                 captureFormSubmits: true,
                 captureFormChanges: true,
@@ -1008,7 +1012,7 @@
                 ignoreClasses: ['journium-ignore'],
                 ignoreElements: ['script', 'style', 'noscript'],
                 captureContentText: true,
-                ...config,
+                ...options,
             };
         }
         start() {
@@ -1016,16 +1020,16 @@
                 return;
             }
             this.isActive = true;
-            if (this.config.captureClicks) {
+            if (this.options.captureClicks) {
                 this.addClickListener();
             }
-            if (this.config.captureFormSubmits) {
+            if (this.options.captureFormSubmits) {
                 this.addFormSubmitListener();
             }
-            if (this.config.captureFormChanges) {
+            if (this.options.captureFormChanges) {
                 this.addFormChangeListener();
             }
-            if (this.config.captureTextSelection) {
+            if (this.options.captureTextSelection) {
                 this.addTextSelectionListener();
             }
         }
@@ -1109,17 +1113,17 @@
                 return true;
             }
             // Check if element should be ignored by tag name
-            if ((_a = this.config.ignoreElements) === null || _a === void 0 ? void 0 : _a.includes(element.tagName.toLowerCase())) {
+            if ((_a = this.options.ignoreElements) === null || _a === void 0 ? void 0 : _a.includes(element.tagName.toLowerCase())) {
                 return true;
             }
             // Check if element has ignore classes
-            if ((_b = this.config.ignoreClasses) === null || _b === void 0 ? void 0 : _b.some(cls => element.classList.contains(cls))) {
+            if ((_b = this.options.ignoreClasses) === null || _b === void 0 ? void 0 : _b.some(cls => element.classList.contains(cls))) {
                 return true;
             }
             // Check parent elements for ignore classes
             let parent = element.parentElement;
             while (parent) {
-                if ((_c = this.config.ignoreClasses) === null || _c === void 0 ? void 0 : _c.some(cls => parent.classList.contains(cls))) {
+                if ((_c = this.options.ignoreClasses) === null || _c === void 0 ? void 0 : _c.some(cls => parent.classList.contains(cls))) {
                     return true;
                 }
                 parent = parent.parentElement;
@@ -1151,7 +1155,7 @@
                 }
             });
             // Element content
-            if (this.config.captureContentText) {
+            if (this.options.captureContentText) {
                 const text = this.getElementText(element);
                 if (text) {
                     properties.$element_text = text.substring(0, 200); // Limit text length
@@ -1338,18 +1342,18 @@
         }
     }
 
-    class Journium {
+    class JourniumAnalytics {
         constructor(config) {
             var _a, _b;
             this.config = config;
             this.client = new JourniumClient(config);
             this.pageviewTracker = new PageviewTracker(this.client);
-            const autocaptureConfig = this.resolveAutocaptureConfig((_a = config.config) === null || _a === void 0 ? void 0 : _a.autocapture);
-            this.autocaptureTracker = new AutocaptureTracker(this.client, autocaptureConfig);
+            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.config) === null || _b === void 0 ? void 0 : _b.autocapture) !== false;
+            this.autocaptureEnabled = ((_b = config.options) === null || _b === void 0 ? void 0 : _b.autocapture) !== false;
         }
-        resolveAutocaptureConfig(autocapture) {
+        resolveAutocaptureOptions(autocapture) {
             if (autocapture === false) {
                 return {
                     captureClicks: false,
@@ -1376,7 +1380,12 @@
             this.pageviewTracker.capturePageview(properties);
         }
         startAutocapture() {
-            this.pageviewTracker.startAutocapture();
+            // Check if automatic pageview tracking is enabled (defaults to true)
+            const effectiveOptions = this.client.getEffectiveOptions();
+            const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+            if (autoTrackPageviews) {
+                this.pageviewTracker.startAutocapture();
+            }
             if (this.autocaptureEnabled) {
                 this.autocaptureTracker.start();
             }
@@ -1388,6 +1397,9 @@
         async flush() {
             return this.client.flush();
         }
+        getEffectiveOptions() {
+            return this.client.getEffectiveOptions();
+        }
         destroy() {
             this.pageviewTracker.stopAutocapture();
             this.autocaptureTracker.stop();
@@ -1395,15 +1407,15 @@
         }
     }
     const init = (config) => {
-        return new Journium(config);
+        return new JourniumAnalytics(config);
     };
 
     exports.AutocaptureTracker = AutocaptureTracker;
     exports.BrowserIdentityManager = BrowserIdentityManager;
-    exports.Journium = Journium;
+    exports.JourniumAnalytics = JourniumAnalytics;
     exports.JourniumClient = JourniumClient;
     exports.PageviewTracker = PageviewTracker;
-    exports.fetchRemoteConfig = fetchRemoteConfig;
+    exports.fetchRemoteOptions = fetchRemoteOptions;
     exports.generateId = generateId;
     exports.generateUuidv7 = generateUuidv7;
     exports.getCurrentTimestamp = getCurrentTimestamp;
@@ -1413,7 +1425,7 @@
     exports.init = init;
     exports.isBrowser = isBrowser;
     exports.isNode = isNode;
-    exports.mergeConfigs = mergeConfigs;
+    exports.mergeOptions = mergeOptions;
 
 }));
 //# sourceMappingURL=index.umd.js.map