@journium/react 1.1.3 → 1.2.0

package/dist/index.d.ts

@@ -13,14 +13,37 @@ interface JourniumProviderProps {
     children: ReactNode;
     config: JourniumConfig;
 }
+/**
+ * Provides the Journium analytics instance to the React tree.
+ * Initializes the SDK on mount and tears it down on unmount.
+ * Re-initializes if `config` changes.
+ */
 declare const JourniumProvider: React$1.FC<JourniumProviderProps>;
+/**
+ * Access the Journium analytics instance and effective options from any component
+ * inside `JourniumProvider`. Throws if called outside the provider.
+ */
 declare const useJournium: () => JourniumContextValue;
 
+/** Returns a stable callback for tracking custom events. */
 declare const useTrackEvent: () => (event: string, properties?: Record<string, unknown>) => void;
+/** Returns a stable callback for identifying the current user. */
 declare const useIdentify: () => (distinctId: string, attributes?: Record<string, unknown>) => void;
+/** Returns a stable callback for resetting the current identity and starting a new anonymous session. */
 declare const useReset: () => () => void;
+/** Returns a stable callback for manually capturing a $pageview event. */
 declare const useTrackPageview: () => (properties?: Record<string, unknown>) => void;
+/**
+ * Automatically captures a $pageview whenever the given dependencies change.
+ * Also fires once on mount. Useful for manual SPA route tracking when automatic
+ * tracking is disabled.
+ */
 declare const useAutoTrackPageview: (dependencies?: React.DependencyList, properties?: Record<string, unknown>) => void;
+/**
+ * Returns `stopAutocapture` to pause DOM event capture and pageview tracking.
+ * `startAutocapture` is also exposed for restarting after an explicit stop,
+ * but under normal usage autocapture starts automatically on SDK init.
+ */
 declare const useAutocapture: () => {
     startAutocapture: () => void;
     stopAutocapture: () => void;

package/dist/index.mjs

@@ -1102,28 +1102,31 @@ class PageviewTracker {
      * Start automatic autocapture for pageviews
      * @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.
+     * @param patchHistory - whether to monkey-patch pushState/replaceState/popstate (default: true).
+     *   Pass false when a framework-native router tracker (e.g. Next.js) owns SPA pageviews.
      */
-    startAutoPageviewTracking(captureInitialPageview = true) {
+    startAutoPageviewTracking(captureInitialPageview = true, patchHistory = true) {
         if (captureInitialPageview) {
             this.capturePageview();
         }
-        if (typeof window !== 'undefined') {
-            // Store original methods for cleanup
-            this.originalPushState = window.history.pushState;
-            this.originalReplaceState = window.history.replaceState;
-            window.history.pushState = (...args) => {
-                this.originalPushState.apply(window.history, args);
-                setTimeout(() => this.capturePageview(), 0);
-            };
-            window.history.replaceState = (...args) => {
-                this.originalReplaceState.apply(window.history, args);
-                setTimeout(() => this.capturePageview(), 0);
-            };
-            this.popStateHandler = () => {
-                setTimeout(() => this.capturePageview(), 0);
-            };
-            window.addEventListener('popstate', this.popStateHandler);
+        if (!patchHistory || typeof window === 'undefined') {
+            return;
         }
+        // Store original methods for cleanup
+        this.originalPushState = window.history.pushState;
+        this.originalReplaceState = window.history.replaceState;
+        window.history.pushState = (...args) => {
+            this.originalPushState.apply(window.history, args);
+            setTimeout(() => this.capturePageview(), 0);
+        };
+        window.history.replaceState = (...args) => {
+            this.originalReplaceState.apply(window.history, args);
+            setTimeout(() => this.capturePageview(), 0);
+        };
+        this.popStateHandler = () => {
+            setTimeout(() => this.capturePageview(), 0);
+        };
+        window.addEventListener('popstate', this.popStateHandler);
     }
     /**
      * Stop automatic autocapture for pageviews
@@ -1538,6 +1541,20 @@ class JourniumAnalytics {
         // This handles cached remote options or local options with autocapture enabled
         this.startAutocaptureIfEnabled(initialEffectiveOptions);
     }
+    resolvePageviewOptions(autoTrackPageviews) {
+        if (autoTrackPageviews === false) {
+            return { enabled: false, trackSpaPageviews: false, captureInitialPageview: false };
+        }
+        if (autoTrackPageviews === true || autoTrackPageviews === undefined) {
+            return { enabled: true, trackSpaPageviews: true, captureInitialPageview: true };
+        }
+        // object form implies enabled
+        return {
+            enabled: true,
+            trackSpaPageviews: autoTrackPageviews.trackSpaPageviews !== false,
+            captureInitialPageview: autoTrackPageviews.trackInitialPageview !== false,
+        };
+    }
     resolveAutocaptureOptions(autocapture) {
         if (autocapture === false) {
             return {
@@ -1552,39 +1569,50 @@ class JourniumAnalytics {
         }
         return autocapture;
     }
+    /** Track a custom event with optional properties. */
     track(event, properties) {
         this.client.track(event, properties);
     }
+    /** Associate the current session with a known user identity and optional attributes. */
     identify(distinctId, attributes) {
         this.client.identify(distinctId, attributes);
     }
+    /** Clear the current identity, starting a new anonymous session. */
     reset() {
         this.client.reset();
     }
+    /** Manually capture a $pageview event with optional custom properties. */
     capturePageview(properties) {
         this.pageviewTracker.capturePageview(properties);
     }
+    /**
+     * Manually start autocapture (pageview tracking + DOM event capture).
+     * Under normal usage this is not needed — the SDK starts automatically on init.
+     * Useful only if autocapture was explicitly stopped and needs to be restarted.
+     */
     startAutocapture() {
         // Always check effective options (which may include remote options)
         const effectiveOptions = this.client.getEffectiveOptions();
-        // Only enable if effectiveOptions are loaded and autoTrackPageviews is not explicitly false
-        const autoTrackPageviews = effectiveOptions && Object.keys(effectiveOptions).length > 0
-            ? effectiveOptions.autoTrackPageviews !== false
-            : false;
-        const autocaptureEnabled = effectiveOptions && Object.keys(effectiveOptions).length > 0
+        // Only start if effectiveOptions are actually loaded (non-empty)
+        const hasOptions = effectiveOptions && Object.keys(effectiveOptions).length > 0;
+        const { enabled: autoTrackPageviews, trackSpaPageviews, captureInitialPageview } = hasOptions
+            ? this.resolvePageviewOptions(effectiveOptions.autoTrackPageviews)
+            : { enabled: false, trackSpaPageviews: false, captureInitialPageview: false };
+        const autocaptureEnabled = hasOptions
             ? effectiveOptions.autocapture !== false
             : false;
         // Update autocapture tracker options if they've changed
         const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
         this.autocaptureTracker.updateOptions(autocaptureOptions);
         if (autoTrackPageviews) {
-            this.pageviewTracker.startAutoPageviewTracking();
+            this.pageviewTracker.startAutoPageviewTracking(captureInitialPageview, trackSpaPageviews);
         }
         if (autocaptureEnabled) {
             this.autocaptureTracker.start();
         }
         this.autocaptureStarted = true;
     }
+    /** Stop autocapture — pauses pageview tracking and DOM event capture. */
     stopAutocapture() {
         this.pageviewTracker.stopAutocapture();
         this.autocaptureTracker.stop();
@@ -1604,13 +1632,13 @@ class JourniumAnalytics {
         const hasActualOptions = effectiveOptions && Object.keys(effectiveOptions).length > 0;
         if (hasActualOptions) {
             // Use same logic as manual startAutocapture() but only start automatically
-            const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+            const { enabled: autoTrackPageviews, trackSpaPageviews, captureInitialPageview } = this.resolvePageviewOptions(effectiveOptions.autoTrackPageviews);
             const autocaptureEnabled = effectiveOptions.autocapture !== false;
             // Update autocapture tracker options
             const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
             this.autocaptureTracker.updateOptions(autocaptureOptions);
             if (autoTrackPageviews) {
-                this.pageviewTracker.startAutoPageviewTracking();
+                this.pageviewTracker.startAutoPageviewTracking(captureInitialPageview, trackSpaPageviews);
             }
             if (autocaptureEnabled) {
                 this.autocaptureTracker.start();
@@ -1635,21 +1663,23 @@ class JourniumAnalytics {
             this.autocaptureTracker.stop();
             this.autocaptureStarted = false;
         }
-        const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+        const { enabled: autoTrackPageviews, trackSpaPageviews, captureInitialPageview } = this.resolvePageviewOptions(effectiveOptions.autoTrackPageviews);
         const autocaptureEnabled = effectiveOptions.autocapture !== false;
         const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
         this.autocaptureTracker.updateOptions(autocaptureOptions);
         if (autoTrackPageviews) {
-            this.pageviewTracker.startAutoPageviewTracking(isFirstStart);
+            this.pageviewTracker.startAutoPageviewTracking(isFirstStart && captureInitialPageview, trackSpaPageviews);
         }
         if (autocaptureEnabled) {
             this.autocaptureTracker.start();
         }
         this.autocaptureStarted = autoTrackPageviews || autocaptureEnabled;
     }
+    /** Flush all queued events to the ingestion endpoint immediately. */
     async flush() {
         return this.client.flush();
     }
+    /** Return the currently active options (merged local + remote config). */
     getEffectiveOptions() {
         return this.client.getEffectiveOptions();
     }
@@ -1659,6 +1689,7 @@ class JourniumAnalytics {
     onOptionsChange(callback) {
         return this.client.onOptionsChange(callback);
     }
+    /** Tear down the analytics instance: stop all tracking, flush pending events, and release resources. */
     destroy() {
         this.pageviewTracker.stopAutocapture();
         this.autocaptureTracker.stop();
@@ -1668,11 +1699,17 @@ class JourniumAnalytics {
         this.client.destroy();
     }
 }
+/** Create and return a new JourniumAnalytics instance for the given config. */
 const init = (config) => {
     return new JourniumAnalytics(config);
 };
 
 const JourniumContext = createContext(undefined);
+/**
+ * Provides the Journium analytics instance to the React tree.
+ * Initializes the SDK on mount and tears it down on unmount.
+ * Re-initializes if `config` changes.
+ */
 const JourniumProvider = ({ children, config, }) => {
     const [analytics, setAnalytics] = useState(null);
     const [effectiveOptions, setEffectiveOptions] = useState(null);
@@ -1700,6 +1737,10 @@ const JourniumProvider = ({ children, config, }) => {
     }, [config]);
     return (React.createElement(JourniumContext.Provider, { value: { analytics, config, effectiveOptions } }, children));
 };
+/**
+ * Access the Journium analytics instance and effective options from any component
+ * inside `JourniumProvider`. Throws if called outside the provider.
+ */
 const useJournium = () => {
     const context = useContext(JourniumContext);
     if (!context) {
@@ -1708,6 +1749,7 @@ const useJournium = () => {
     return context;
 };
 
+/** Returns a stable callback for tracking custom events. */
 const useTrackEvent = () => {
     const { analytics } = useJournium();
     return useCallback((event, properties) => {
@@ -1716,6 +1758,7 @@ const useTrackEvent = () => {
         }
     }, [analytics]);
 };
+/** Returns a stable callback for identifying the current user. */
 const useIdentify = () => {
     const { analytics } = useJournium();
     return useCallback((distinctId, attributes) => {
@@ -1724,6 +1767,7 @@ const useIdentify = () => {
         }
     }, [analytics]);
 };
+/** Returns a stable callback for resetting the current identity and starting a new anonymous session. */
 const useReset = () => {
     const { analytics } = useJournium();
     return useCallback(() => {
@@ -1732,6 +1776,7 @@ const useReset = () => {
         }
     }, [analytics]);
 };
+/** Returns a stable callback for manually capturing a $pageview event. */
 const useTrackPageview = () => {
     const { analytics } = useJournium();
     return useCallback((properties) => {
@@ -1740,12 +1785,22 @@ const useTrackPageview = () => {
         }
     }, [analytics]);
 };
+/**
+ * Automatically captures a $pageview whenever the given dependencies change.
+ * Also fires once on mount. Useful for manual SPA route tracking when automatic
+ * tracking is disabled.
+ */
 const useAutoTrackPageview = (dependencies = [], properties) => {
     const trackPageview = useTrackPageview();
     useEffect(() => {
         trackPageview(properties);
     }, [trackPageview, properties, ...dependencies]);
 };
+/**
+ * Returns `stopAutocapture` to pause DOM event capture and pageview tracking.
+ * `startAutocapture` is also exposed for restarting after an explicit stop,
+ * but under normal usage autocapture starts automatically on SDK init.
+ */
 const useAutocapture = () => {
     const { analytics } = useJournium();
     const startAutocapture = useCallback(() => {