@journium/react 1.0.1 → 1.0.3

package/dist/{index.js → index.cjs}

@@ -1,4 +1,6 @@
-import React, { createContext, useState, useEffect, useContext, useCallback } from 'react';
+'use strict';
+
+var React = require('react');
 
 /**
  * uuidv7: A JavaScript implementation of UUID version 7
@@ -427,7 +429,7 @@ const isNode = () => {
     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 {
@@ -449,42 +451,43 @@ const fetchRemoteConfig = async (apiHost, publishableKey, fetchFn) => {
             },
         });
         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;
             }
         }
     });
@@ -588,7 +591,7 @@ class BrowserIdentityManager {
         };
         this.saveIdentity();
     }
-    identify(distinctId, attributes = {}) {
+    identify(distinctId, _attributes = {}) {
         if (!this.identity)
             return { previousDistinctId: null };
         const previousDistinctId = this.identity.distinct_id;
@@ -681,113 +684,113 @@ class JourniumClient {
             ...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);
             }
         }
     }
@@ -798,7 +801,7 @@ class JourniumClient {
         // 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)
@@ -817,12 +820,12 @@ class JourniumClient {
             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;
@@ -832,7 +835,7 @@ class JourniumClient {
         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;
@@ -845,7 +848,7 @@ class JourniumClient {
             $anon_distinct_id: previousDistinctId,
         };
         this.track('$identify', identifyProperties);
-        if (this.effectiveConfig.debug) {
+        if (this.effectiveOptions.debug) {
             console.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
         }
     }
@@ -853,14 +856,14 @@ class JourniumClient {
         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');
         }
     }
@@ -868,7 +871,7 @@ class JourniumClient {
         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;
@@ -896,10 +899,10 @@ class JourniumClient {
             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();
         }
     }
@@ -927,6 +930,9 @@ class JourniumClient {
         }
         this.flush();
     }
+    getEffectiveOptions() {
+        return this.effectiveOptions;
+    }
 }
 
 class PageviewTracker {
@@ -992,11 +998,11 @@ class PageviewTracker {
 }
 
 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,
@@ -1004,7 +1010,7 @@ class AutocaptureTracker {
             ignoreClasses: ['journium-ignore'],
             ignoreElements: ['script', 'style', 'noscript'],
             captureContentText: true,
-            ...config,
+            ...options,
         };
     }
     start() {
@@ -1012,16 +1018,16 @@ class AutocaptureTracker {
             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();
         }
     }
@@ -1105,17 +1111,17 @@ class AutocaptureTracker {
             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;
@@ -1147,7 +1153,7 @@ class AutocaptureTracker {
             }
         });
         // 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
@@ -1334,18 +1340,18 @@ class AutocaptureTracker {
     }
 }
 
-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,
@@ -1372,7 +1378,12 @@ class Journium {
         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();
         }
@@ -1384,6 +1395,9 @@ class Journium {
     async flush() {
         return this.client.flush();
     }
+    getEffectiveOptions() {
+        return this.client.getEffectiveOptions();
+    }
     destroy() {
         this.pageviewTracker.stopAutocapture();
         this.autocaptureTracker.stop();
@@ -1391,32 +1405,33 @@ class Journium {
     }
 }
 const init = (config) => {
-    return new Journium(config);
+    return new JourniumAnalytics(config);
 };
 
-const JourniumContext = createContext({ journium: null });
+const JourniumContext = React.createContext({ analytics: null, config: null, effectiveOptions: null });
 const JourniumProvider = ({ children, config, }) => {
-    const [journium, setJournium] = useState(null);
-    useEffect(() => {
-        var _a;
-        const journiumInstance = new Journium(config);
-        // Check if autocapture is enabled (defaults to true if not specified)
-        const autocaptureEnabled = ((_a = config.config) === null || _a === void 0 ? void 0 : _a.autocapture) !== false;
+    const [analytics, setAnalytics] = React.useState(null);
+    const [effectiveOptions, setEffectiveOptions] = React.useState(null);
+    React.useEffect(() => {
+        const analyticsInstance = new JourniumAnalytics(config);
+        // Get effective options and check if autocapture is enabled
+        const effective = analyticsInstance.getEffectiveOptions();
+        setEffectiveOptions(effective);
+        const autocaptureEnabled = effective.autocapture !== false;
         if (autocaptureEnabled) {
-            journiumInstance.startAutocapture();
+            analyticsInstance.startAutocapture();
         }
-        setJournium(journiumInstance);
+        setAnalytics(analyticsInstance);
         return () => {
-            journiumInstance.destroy();
-            setJournium(null);
+            analyticsInstance.destroy();
+            setAnalytics(null);
+            setEffectiveOptions(null);
         };
     }, [config]);
-    // Note: All pageview tracking is handled by startAutocapture() when autocapture=true
-    // When autocapture=false, users should call capturePageview() manually as needed
-    return (React.createElement(JourniumContext.Provider, { value: { journium } }, children));
+    return (React.createElement(JourniumContext.Provider, { value: { analytics, config, effectiveOptions } }, children));
 };
 const useJournium = () => {
-    const context = useContext(JourniumContext);
+    const context = React.useContext(JourniumContext);
     if (!context) {
         throw new Error('useJournium must be used within a JourniumProvider');
     }
@@ -1424,57 +1439,80 @@ const useJournium = () => {
 };
 
 const useTrackEvent = () => {
-    const { journium } = useJournium();
-    return useCallback((event, properties) => {
-        if (journium) {
-            journium.track(event, properties);
+    const { analytics } = useJournium();
+    return React.useCallback((event, properties) => {
+        if (analytics) {
+            analytics.track(event, properties);
         }
-    }, [journium]);
+    }, [analytics]);
 };
 const useIdentify = () => {
-    const { journium } = useJournium();
-    return useCallback((distinctId, attributes) => {
-        if (journium) {
-            journium.identify(distinctId, attributes);
+    const { analytics } = useJournium();
+    return React.useCallback((distinctId, attributes) => {
+        if (analytics) {
+            analytics.identify(distinctId, attributes);
         }
-    }, [journium]);
+    }, [analytics]);
 };
 const useReset = () => {
-    const { journium } = useJournium();
-    return useCallback(() => {
-        if (journium) {
-            journium.reset();
+    const { analytics } = useJournium();
+    return React.useCallback(() => {
+        if (analytics) {
+            analytics.reset();
         }
-    }, [journium]);
+    }, [analytics]);
 };
 const useTrackPageview = () => {
-    const { journium } = useJournium();
-    return useCallback((properties) => {
-        if (journium) {
-            journium.capturePageview(properties);
+    const { analytics } = useJournium();
+    return React.useCallback((properties) => {
+        if (analytics) {
+            analytics.capturePageview(properties);
         }
-    }, [journium]);
+    }, [analytics]);
 };
 const useAutoTrackPageview = (dependencies = [], properties) => {
     const trackPageview = useTrackPageview();
-    useEffect(() => {
+    React.useEffect(() => {
         trackPageview(properties);
-    }, dependencies);
+    }, [trackPageview, properties, ...dependencies]);
 };
 const useAutocapture = () => {
-    const { journium } = useJournium();
-    const startAutocapture = useCallback(() => {
-        if (journium) {
-            journium.startAutocapture();
+    const { analytics } = useJournium();
+    const startAutocapture = React.useCallback(() => {
+        if (analytics) {
+            analytics.startAutocapture();
         }
-    }, [journium]);
-    const stopAutocapture = useCallback(() => {
-        if (journium) {
-            journium.stopAutocapture();
+    }, [analytics]);
+    const stopAutocapture = React.useCallback(() => {
+        if (analytics) {
+            analytics.stopAutocapture();
         }
-    }, [journium]);
+    }, [analytics]);
     return { startAutocapture, stopAutocapture };
 };
 
-export { AutocaptureTracker, BrowserIdentityManager, Journium, JourniumClient, JourniumProvider, PageviewTracker, fetchRemoteConfig, generateId, generateUuidv7, getCurrentTimestamp, getCurrentUrl, getPageTitle, getReferrer, init, isBrowser, isNode, mergeConfigs, useAutoTrackPageview, useAutocapture, useIdentify, useJournium, useReset, useTrackEvent, useTrackPageview };
-//# sourceMappingURL=index.js.map
+exports.AutocaptureTracker = AutocaptureTracker;
+exports.BrowserIdentityManager = BrowserIdentityManager;
+exports.JourniumAnalytics = JourniumAnalytics;
+exports.JourniumClient = JourniumClient;
+exports.JourniumProvider = JourniumProvider;
+exports.PageviewTracker = PageviewTracker;
+exports.fetchRemoteOptions = fetchRemoteOptions;
+exports.generateId = generateId;
+exports.generateUuidv7 = generateUuidv7;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.getCurrentUrl = getCurrentUrl;
+exports.getPageTitle = getPageTitle;
+exports.getReferrer = getReferrer;
+exports.init = init;
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;
+exports.mergeOptions = mergeOptions;
+exports.useAutoTrackPageview = useAutoTrackPageview;
+exports.useAutocapture = useAutocapture;
+exports.useIdentify = useIdentify;
+exports.useJournium = useJournium;
+exports.useReset = useReset;
+exports.useTrackEvent = useTrackEvent;
+exports.useTrackPageview = useTrackPageview;
+//# sourceMappingURL=index.cjs.map