humanbehavior-js 0.4.3 → 0.4.5

package/dist/types/remix/index.d.ts

@@ -1,5 +1,229 @@
 import { LoaderFunctionArgs } from '@remix-run/node';
-export { HumanBehaviorProvider, useHumanBehavior } from '../react';
+import React, { ReactNode } from 'react';
+
+interface RedactionOptions {
+    redactedText?: string;
+    excludeSelectors?: string[];
+    userFields?: string[];
+}
+
+declare global {
+    interface Window {
+        HumanBehaviorTracker: typeof HumanBehaviorTracker;
+        __humanBehaviorGlobalTracker?: HumanBehaviorTracker;
+    }
+}
+declare class HumanBehaviorTracker {
+    private eventIngestionQueue;
+    private sessionId;
+    private userProperties;
+    private isProcessing;
+    private flushInterval;
+    private readonly FLUSH_INTERVAL_MS;
+    private api;
+    private endUserId;
+    private apiKey;
+    private initialized;
+    initializationPromise: Promise<void> | null;
+    private redactionManager;
+    private originalConsole;
+    private consoleTrackingEnabled;
+    navigationTrackingEnabled: boolean;
+    private currentUrl;
+    private previousUrl;
+    private originalPushState;
+    private originalReplaceState;
+    private navigationListeners;
+    private _connectionBlocked;
+    private recordInstance;
+    private sessionStartTime;
+    /**
+     * Initialize the HumanBehavior tracker
+     * This is the main entry point - call this once per page
+     */
+    static init(apiKey: string, options?: {
+        ingestionUrl?: string;
+        logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+        redactFields?: string[];
+        enableAutomaticTracking?: boolean;
+        automaticTrackingOptions?: {
+            trackButtons?: boolean;
+            trackLinks?: boolean;
+            trackForms?: boolean;
+            includeText?: boolean;
+            includeClasses?: boolean;
+        };
+    }): HumanBehaviorTracker;
+    constructor(apiKey: string | undefined, ingestionUrl?: string);
+    private init;
+    private ensureInitialized;
+    /**
+     * Setup navigation event tracking for SPA navigation
+     */
+    private setupNavigationTracking;
+    /**
+     * Track navigation events and send custom events
+     */
+    trackNavigationEvent(type: string, fromUrl: string, toUrl: string): Promise<void>;
+    trackPageView(url?: string): Promise<void>;
+    customEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
+    /**
+     * Setup automatic tracking for buttons, links, and forms
+     */
+    private setupAutomaticTracking;
+    /**
+     * Setup automatic button tracking
+     */
+    private setupAutomaticButtonTracking;
+    /**
+     * Setup automatic link tracking
+     */
+    private setupAutomaticLinkTracking;
+    /**
+     * Setup automatic form tracking
+     */
+    private setupAutomaticFormTracking;
+    /**
+     * Cleanup navigation tracking
+     */
+    private cleanupNavigationTracking;
+    static logToStorage(message: string): void;
+    /**
+     * Configure logging behavior for the SDK
+     * @param config Logger configuration options
+     */
+    static configureLogging(config: {
+        level?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+        enableConsole?: boolean;
+        enableStorage?: boolean;
+    }): void;
+    /**
+     * Enable console event tracking
+     */
+    enableConsoleTracking(): void;
+    /**
+     * Disable console event tracking
+     */
+    disableConsoleTracking(): void;
+    private trackConsoleEvent;
+    private setupPageUnloadHandler;
+    viewLogs(): void;
+    /**
+     * Add user identification information to the tracker
+     * If userId is not provided, will use userProperties.email as the userId (if present)
+     */
+    identifyUser({ userProperties }: {
+        userProperties: Record<string, any>;
+    }): Promise<string>;
+    /**
+     * Get current user attributes
+     */
+    getUserAttributes(): Record<string, any>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Add an event to the ingestion queue
+     * Events are sent directly without processing to avoid corruption
+     */
+    addEvent(event: any): Promise<void>;
+    /**
+     * Flush events to the ingestion server
+     * Events are sent in chunks to handle large payloads efficiently
+     */
+    private flush;
+    private setCookie;
+    getCookie(name: string): string | null;
+    /**
+     * Delete a cookie by setting its expiration date to the past
+     * @param name The name of the cookie to delete
+     */
+    private deleteCookie;
+    /**
+     * Clear user data and reset session when user signs out of the site
+     * This should be called when a user logs out of your application to prevent
+     * data contamination between different users
+     */
+    logout(): void;
+    /**
+     * Start redaction functionality for sensitive input fields
+     * @param options Optional configuration for redaction behavior
+     */
+    redact(options?: RedactionOptions): Promise<void>;
+    /**
+     * Set specific fields to be redacted during session recording
+     * Uses rrweb's built-in masking instead of custom redaction processing
+     * @param fields Array of CSS selectors for fields to redact (e.g., ['input[type="password"]', '#email-field'])
+     */
+    setRedactedFields(fields: string[]): void;
+    private restartWithNewRedaction;
+    /**
+     * Check if redaction is currently active
+     */
+    isRedactionActive(): boolean;
+    /**
+     * Get the currently selected fields for redaction
+     */
+    getRedactedFields(): string[];
+    /**
+     * Get the current session ID
+     */
+    getSessionId(): string;
+    /**
+     * Get the current URL being tracked
+     */
+    getCurrentUrl(): string;
+    /**
+     * Get current snapshot frequency info
+     * Uses configured values (5 minutes, 1000 events)
+     */
+    getSnapshotFrequencyInfo(): {
+        sessionDuration: number;
+        currentInterval: number;
+        currentThreshold: number;
+        phase: string;
+    };
+    /**
+     * Test if the tracker can reach the ingestion server
+     */
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get connection status and recommendations
+     */
+    getConnectionStatus(): {
+        blocked: boolean;
+        recommendations: string[];
+    };
+    /**
+     * Check if the current user is a preexisting user
+     * Returns true if the user has an existing endUserId cookie from a previous session
+     */
+    isPreexistingUser(): boolean;
+    /**
+     * Get user information including whether they are preexisting
+     */
+    getUserInfo(): {
+        endUserId: string | null;
+        sessionId: string;
+        isPreexistingUser: boolean;
+        initialized: boolean;
+    };
+}
+
+interface HumanBehaviorProviderProps {
+    apiKey?: string;
+    client?: HumanBehaviorTracker;
+    children: ReactNode;
+    options?: {
+        ingestionUrl?: string;
+        logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+        redactFields?: string[];
+    };
+}
+declare const HumanBehaviorProvider: ({ apiKey, client, children, options }: HumanBehaviorProviderProps) => React.JSX.Element;
+declare const useHumanBehavior: () => HumanBehaviorTracker;
 
 declare function createHumanBehaviorLoader(): ({ request }: LoaderFunctionArgs) => Promise<{
     ENV: {
@@ -7,4 +231,4 @@ declare function createHumanBehaviorLoader(): ({ request }: LoaderFunctionArgs)
     };
 }>;
 
-export { createHumanBehaviorLoader };
+export { HumanBehaviorProvider, createHumanBehaviorLoader, useHumanBehavior };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanbehavior-js",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "SDK for HumanBehavior session and event recording",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/src/angular/index.ts

@@ -1,4 +1,4 @@
-import { HumanBehaviorTracker } from '../index';
+import { HumanBehaviorTracker } from '../index.js';
 
 // Angular NgModule for legacy Angular applications
 export class HumanBehaviorModule {

package/src/remix/index.ts

@@ -1,4 +1,4 @@
-import { HumanBehaviorTracker } from '../index';
+import { HumanBehaviorTracker } from '../index.js';
 import type { LoaderFunctionArgs } from '@remix-run/node';
 
 // Remix-specific loader helper
@@ -13,4 +13,4 @@ export function createHumanBehaviorLoader() {
 }
 
 // Re-export React components for convenience
-export { HumanBehaviorProvider, useHumanBehavior } from '../react'; 
+export { HumanBehaviorProvider, useHumanBehavior } from '../react/index.js'; 

package/src/tracker.ts

@@ -126,8 +126,8 @@ export class HumanBehaviorTracker {
 
         // Handle session restoration with improved continuity
         if (isBrowser) {
-            const existingSessionId = localStorage.getItem('human_behavior_session_id');
-            const lastActivity = localStorage.getItem('human_behavior_last_activity');
+            const existingSessionId = localStorage.getItem(`human_behavior_session_id_${this.apiKey}`);
+            const lastActivity = localStorage.getItem(`human_behavior_last_activity_${this.apiKey}`);
             const fifteenMinutesAgo = Date.now() - (15 * 60 * 1000);
             
             // Check if we have an existing session that's still within the activity window
@@ -135,18 +135,18 @@ export class HumanBehaviorTracker {
                 this.sessionId = existingSessionId;
                 logDebug(`Reusing existing session: ${this.sessionId}`);
                 // Update activity timestamp to extend the session window
-                localStorage.setItem('human_behavior_last_activity', Date.now().toString());
+                localStorage.setItem(`human_behavior_last_activity_${this.apiKey}`, Date.now().toString());
             } else {
                 // Clear old session data if it's expired
                 if (existingSessionId) {
                     logDebug(`Session expired, clearing old session: ${existingSessionId}`);
-                    localStorage.removeItem('human_behavior_session_id');
-                    localStorage.removeItem('human_behavior_last_activity');
+                    localStorage.removeItem(`human_behavior_session_id_${this.apiKey}`);
+                    localStorage.removeItem(`human_behavior_last_activity_${this.apiKey}`);
                 }
                 this.sessionId = uuidv1();
                 logDebug(`Creating new session: ${this.sessionId}`);
-                localStorage.setItem('human_behavior_session_id', this.sessionId);
-                localStorage.setItem('human_behavior_last_activity', Date.now().toString());
+                localStorage.setItem(`human_behavior_session_id_${this.apiKey}`, this.sessionId);
+                localStorage.setItem(`human_behavior_last_activity_${this.apiKey}`, Date.now().toString());
             }
             
             this.currentUrl = window.location.href;
@@ -172,7 +172,7 @@ export class HumanBehaviorTracker {
                 this.sessionId = sessionId;
                 // Update localStorage with server's session ID for continuity
                 if (isBrowser) {
-                    localStorage.setItem('human_behavior_session_id', this.sessionId);
+                    localStorage.setItem(`human_behavior_session_id_${this.apiKey}`, this.sessionId);
                 }
             }
             
@@ -693,7 +693,7 @@ export class HumanBehaviorTracker {
 
         // Update activity timestamp on user interaction (not on page load)
         const updateActivity = () => {
-            localStorage.setItem('human_behavior_last_activity', Date.now().toString());
+            localStorage.setItem(`human_behavior_last_activity_${this.apiKey}`, Date.now().toString());
         };
 
         // Listen for user interactions to update activity timestamp
@@ -1013,8 +1013,8 @@ export class HumanBehaviorTracker {
             this.deleteCookie(userIdCookieName);
             
             // Clear session data from localStorage
-            localStorage.removeItem('human_behavior_session_id');
-            localStorage.removeItem('human_behavior_last_activity');
+            localStorage.removeItem(`human_behavior_session_id_${this.apiKey}`);
+            localStorage.removeItem(`human_behavior_last_activity_${this.apiKey}`);
             
             // Reset user-related properties
             this.endUserId = null;
@@ -1023,8 +1023,8 @@ export class HumanBehaviorTracker {
             // Generate a new session ID for the next user
             this.sessionId = uuidv1();
             if (isBrowser) {
-                localStorage.setItem('human_behavior_session_id', this.sessionId);
-                localStorage.setItem('human_behavior_last_activity', Date.now().toString());
+                localStorage.setItem(`human_behavior_session_id_${this.apiKey}`, this.sessionId);
+                localStorage.setItem(`human_behavior_last_activity_${this.apiKey}`, Date.now().toString());
             }
             
             logInfo('User logged out - cleared all user data and started fresh session');

package/src/vue/index.ts

@@ -1,4 +1,4 @@
-import { HumanBehaviorTracker } from '../index';
+import { HumanBehaviorTracker } from '../index.js';
 import type { App } from 'vue';
 
 interface HumanBehaviorPluginOptions {