humanbehavior-js 0.0.9 → 0.1.1

package/src/api.ts

@@ -199,7 +199,7 @@ export class HumanBehaviorAPI {
             if (!response.ok) {
                 throw new Error(`Failed to authenticate user: ${response.statusText} with API key: ${this.apiKey}`);
             }
-            
+            // Returns: { success: true, message: '...', userId: '...' }
             return await response.json();
         } catch (error) {
             logError('Error authenticating user:', error);
@@ -207,156 +207,16 @@ export class HumanBehaviorAPI {
         }
     }
 
-    async sendSessionComplete(sessionId: string) {
-        const response = await fetch(`${this.baseUrl}/api/ingestion/sessionComplete`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`
-            },
-            body: JSON.stringify({ sessionId })
-        });
-        
-        if (!response.ok) {
-            throw new Error(`Failed to send session complete: ${response.statusText}`);
-        }
-    }
-
-    async sendCustomEvent(eventName: string, eventProperties: Record<string, any>, sessionId: string) {
-        const maxRetries = 3;
-        let retryCount = 0;
-        
-        while (retryCount < maxRetries) {
-            try {
-                const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.apiKey}`
-                    },
-                    body: JSON.stringify({
-                        name: eventName,
-                        properties: eventProperties,
-                        sessionId: sessionId,
-                        timestamp: new Date().toISOString()
-                    })
-                });
-                
-                if (!response.ok) {
-                    throw new Error(`Failed to send custom event: ${response.statusText}`);
-                }
-                
-                return await response.json();
-            } catch (error) {
-                retryCount++;
-                if (retryCount === maxRetries) {
-                    logError('Error sending custom event after max retries:', error);
-                    throw error;
-                }
-                // Exponential backoff
-                await new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
-            }
-        }
-    }
-
-    async sendCustomEvents(events: any[], sessionId: string) {
-        const maxRetries = 3;
-        let retryCount = 0;
-        
-        while (retryCount < maxRetries) {
-            try {
-                const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent/batch`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.apiKey}`
-                    },
-                    body: JSON.stringify({
-                        events: events.map(event => ({
-                            ...event,
-                            sessionId: sessionId
-                        }))
-                    })
-                });
-                
-                if (!response.ok) {
-                    throw new Error(`Failed to send custom events: ${response.statusText}`);
-                }
-                
-                return await response.json();
-            } catch (error) {
-                retryCount++;
-                if (retryCount === maxRetries) {
-                    logError('Error sending custom events after max retries:', error);
-                    throw error;
-                }
-                // Exponential backoff
-                await new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
-            }
-        }
-    }
-
-    public sendBeaconEvents(events: any[], sessionId: string, isSessionComplete: boolean = false) {
+    public sendBeaconEvents(events: any[], sessionId: string) {
         const data = new URLSearchParams()
         data.append('events', encodeURIComponent(JSON.stringify(events)))
         data.append('sessionId', encodeURIComponent(sessionId))
         data.append('timestamp', encodeURIComponent(Date.now().toString()))
         data.append('apiKey', encodeURIComponent(this.apiKey))
-        if (isSessionComplete) {
-            logInfo('Session complete beacon sending');
-            localStorage.setItem('koalaware_session_complete', Date.now().toString());
-            data.append('sessionComplete', encodeURIComponent('true'))
-        }
 
         const success = navigator.sendBeacon(
             `${this.baseUrl}/api/ingestion/events`, 
             data
         );
-
-        // KoalawareTracker.logToStorage(`Sending events beacon: ${this.baseUrl}/api/ingestion/events`);
-        // KoalawareTracker.logToStorage(`Events beacon success: ${success}`);
-    }
-
-    public sendBeaconSessionComplete(sessionId: string) {
-        const data = new URLSearchParams()
-        data.append('sessionId', sessionId)
-        data.append('apiKey', this.apiKey)
-        data.append('sessionComplete', 'true')
-        
-        const success = navigator.sendBeacon(
-            `${this.baseUrl}/api/ingestion/sessionComplete`, 
-            data
-        );
-
-        // KoalawareTracker.logToStorage(`Sending completion beacon: ${this.baseUrl}/api/ingestion/sessionComplete`);
-        // KoalawareTracker.logToStorage(`Complete beacon success: ${success}`);
-    }
-
-    public sendBeaconCustomEvent(eventName: string, eventProperties: Record<string, any>, sessionId: string) {
-        const data = new URLSearchParams()
-        data.append('name', encodeURIComponent(eventName))
-        data.append('properties', encodeURIComponent(JSON.stringify(eventProperties)))
-        data.append('sessionId', encodeURIComponent(sessionId))
-        data.append('timestamp', encodeURIComponent(new Date().toISOString()))
-        data.append('apiKey', encodeURIComponent(this.apiKey))
-
-        return navigator.sendBeacon(
-            `${this.baseUrl}/api/ingestion/customEvent`,
-            data
-        );
-    }
-
-    public sendBeaconCustomEvents(events: any[], sessionId: string) {
-        const data = new URLSearchParams()
-        data.append('events', encodeURIComponent(JSON.stringify(events.map(event => ({
-            ...event,
-            sessionId: sessionId
-        })))))
-        data.append('apiKey', encodeURIComponent(this.apiKey))
-
-        return navigator.sendBeacon(
-            `${this.baseUrl}/api/ingestion/customEvent/batch`,
-            data
-        );
     }
 }

package/src/react/index.tsx

@@ -24,6 +24,11 @@ interface HumanBehaviorProviderProps {
   apiKey?: string;
   client?: HumanBehaviorTracker;
   children: ReactNode;
+  options?: {
+    ingestionUrl?: string;
+    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+    redactFields?: string[];
+  };
 }
 
 // Default context to prevent unnecessary re-renders
@@ -38,9 +43,9 @@ const defaultContext: HumanBehaviorContextType = {
   }
 };
 
-const HumanBehaviorContext = createContext<HumanBehaviorContextType>(defaultContext);
+const HumanBehaviorContext = createContext<HumanBehaviorTracker | null>(null);
 
-export const HumanBehaviorProvider = ({ apiKey, client, children }: HumanBehaviorProviderProps) => {
+export const HumanBehaviorProvider = ({ apiKey, client, children, options }: HumanBehaviorProviderProps) => {
   const [humanBehavior, setHumanBehavior] = useState<HumanBehaviorTracker | null>(client || null);
   const [eventQueue, setEventQueue] = useState<any[]>([]);
   const [isMounted, setIsMounted] = useState(false);
@@ -132,15 +137,15 @@ export const HumanBehaviorProvider = ({ apiKey, client, children }: HumanBehavio
   // Memoized context value to prevent unnecessary re-renders
   const contextValue = useMemo(() => {
     if (!isMounted) {
-      return { humanBehavior: null, queueEvent };
+      return null;
     }
     
     if (!isInitialized) {
-      return { humanBehavior: null, queueEvent };
+      return null;
     }
     
-    return { humanBehavior, queueEvent };
-  }, [isMounted, isInitialized, humanBehavior, queueEvent]);
+    return humanBehavior;
+  }, [isMounted, isInitialized, humanBehavior]);
 
   // If not in browser, render children without context
   if (!(isBrowser())) {
@@ -149,6 +154,7 @@ export const HumanBehaviorProvider = ({ apiKey, client, children }: HumanBehavio
 
   return (
     <HumanBehaviorContext.Provider value={contextValue}>
+      <HumanBehaviorPageView />
       {children}
     </HumanBehaviorContext.Provider>
   );
@@ -185,28 +191,55 @@ const createQueuingImplementation = (queueEvent: (event: any) => void): HumanBeh
   }
 });
 
-export const useHumanBehavior = (): HumanBehaviorInterface => {
-  const context = useContext(HumanBehaviorContext);
-  
-  // Only throw if the hook is used outside of a provider entirely
-  if (context === null) {
-    throw new Error("useHumanBehavior must be used within a HumanBehaviorProvider");
+export const useHumanBehavior = () => {
+  const tracker = useContext(HumanBehaviorContext);
+  if (!tracker) {
+    throw new Error('useHumanBehavior must be used within a HumanBehaviorProvider');
   }
+  return tracker;
+};
 
-  // If we're in the server-side, return a no-op implementation
-  if (typeof window === 'undefined') {
-    logWarn('HumanBehavior is being used before being initialized');
-    return serverSideImplementation;
-  }
-  
-  // If we have an initialized tracker, return it as the interface
-  if (context.humanBehavior) {
-    return context.humanBehavior;
-  }
+// Automatic page tracking component (similar to PostHog's PostHogPageView)
+function HumanBehaviorPageView() {
+  const tracker = useContext(HumanBehaviorContext);
 
-  // If we reach here, we're in the initialization period where:
-  // - context.humanBehavior is null
-  // - context.queueEvent is available
-  // - we need to queue all operations until initialization completes
-  return useMemo(() => createQueuingImplementation(context.queueEvent), [context.queueEvent]);
-};
+  useEffect(() => {
+    if (tracker && typeof window !== 'undefined') {
+      // Track initial page load
+      tracker.trackPageView();
+
+      // Listen for route changes (for SPAs)
+      const handleRouteChange = () => {
+        tracker.trackPageView();
+      };
+
+      // Listen for popstate (back/forward navigation)
+      window.addEventListener('popstate', handleRouteChange);
+
+      // Listen for pushstate/replacestate (programmatic navigation)
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+
+      history.pushState = function(...args) {
+        originalPushState.apply(this, args);
+        handleRouteChange();
+      };
+
+      history.replaceState = function(...args) {
+        originalReplaceState.apply(this, args);
+        handleRouteChange();
+      };
+
+      return () => {
+        window.removeEventListener('popstate', handleRouteChange);
+        history.pushState = originalPushState;
+        history.replaceState = originalReplaceState;
+      };
+    }
+  }, [tracker]);
+
+  return null;
+}
+
+// Export the tracker class for direct use
+export { HumanBehaviorTracker };