humanbehavior-js 0.4.28 → 0.5.0

package/src/react/index.tsx

@@ -1,308 +0,0 @@
-import React, { useEffect, useState, createContext, useContext, ReactNode, useCallback, useMemo, useRef } from "react";
-import { HumanBehaviorTracker, logError, logWarn, logDebug } from "./browser";
-
-// Check if we're in a browser environment
-const isBrowser = () => typeof window !== 'undefined';
-
-// Define the public interface that components will interact with
-interface HumanBehaviorInterface {
-  addEvent: (event: any) => void;
-  identifyUser: ({ userProperties }: { userProperties: Record<string, any> }) => Promise<string>;
-  start: () => void;
-  stop: () => void;
-  logout: () => void;
-  viewLogs: () => void;
-}
-
-interface HumanBehaviorContextType {
-  humanBehavior: HumanBehaviorTracker | null;
-  queueEvent: (event: any) => void;
-}
-
-interface HumanBehaviorProviderProps {
-  // Either provide an apiKey to create a new client, or provide an existing client
-  apiKey?: string;
-  client?: HumanBehaviorTracker;
-  children: ReactNode;
-  options?: {
-    ingestionUrl?: string;
-    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-    redactFields?: string[];
-    suppressConsoleErrors?: boolean;
-    recordCanvas?: boolean; // Enable canvas recording with protection
-  };
-}
-
-// Default context to prevent unnecessary re-renders
-const defaultContext: HumanBehaviorContextType = {
-  humanBehavior: null,
-  queueEvent: (event: any) => {
-    // In server-side, just no-op
-    if (typeof window === 'undefined') {
-      return;
-    }
-    logWarn('HumanBehavior not initialized yet, event queued:', event);
-  }
-};
-
-const HumanBehaviorContext = createContext<HumanBehaviorTracker | null>(null);
-
-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);
-  const [isInitialized, setIsInitialized] = useState(false);
-  
-  // Use refs to avoid dependency issues in useEffect
-  const apiKeyRef = useRef(apiKey);
-  const clientRef = useRef(client);
-  const eventQueueRef = useRef(eventQueue);
-  
-  // Update refs when props change
-  useEffect(() => {
-    apiKeyRef.current = apiKey;
-    clientRef.current = client;
-  }, [apiKey, client]);
-  
-  // Update eventQueue ref when queue changes
-  useEffect(() => {
-    eventQueueRef.current = eventQueue;
-  }, [eventQueue]);
-
-  // Memoized queueEvent function to prevent unnecessary re-renders
-  const queueEvent = useCallback((event: any) => {
-    setEventQueue(prev => [...prev, event]);
-  }, []);
-
-  // Handle mounting state
-  useEffect(() => {
-    setIsMounted(true);
-  }, []);
-
-  useEffect(() => {
-    // Only run in browser
-    if (!(isBrowser())) {
-      return;
-    }
-
-    // Skip if not mounted yet (handles Next.js hydration)
-    if (!isMounted) {
-      return;
-    }
-
-    // If client is provided, use that
-    if (clientRef.current) {
-      setHumanBehavior(clientRef.current);
-      setIsInitialized(true);
-      return;
-    }
-
-    // If no client is provided, apiKey is required
-    if (!apiKeyRef.current || apiKeyRef.current.trim() === '') {
-      logError("An apiKey is required when no client is provided");
-      return;
-    }
-
-    if (humanBehavior !== null) {
-      return;
-    }
-
-    // Create new tracker instance with the validated apiKey and options
-    const tracker = HumanBehaviorTracker.init(
-      apiKeyRef.current.trim(),
-      {
-        ingestionUrl: options?.ingestionUrl,
-        logLevel: options?.logLevel,
-        redactFields: options?.redactFields,
-        suppressConsoleErrors: options?.suppressConsoleErrors,
-        recordCanvas: options?.recordCanvas, // Pass canvas recording option
-      }
-    );
-    
-    setHumanBehavior(tracker);
-
-    // Wait for initialization to complete
-    tracker.initializationPromise?.then(async () => {
-        await tracker.start();
-        setIsInitialized(true);
-        
-      // Process any queued events
-      const currentQueue = eventQueueRef.current;
-      if (currentQueue.length > 0) {
-        for (const event of currentQueue) {
-          if (event.type === 'identify') {
-            logDebug('Processing queued identify event', event);
-            try {
-              await tracker.identifyUser({ userProperties: event.userProperties });
-            } catch (error) {
-              logError('Failed to process queued user info:', error);
-            }
-          } else {
-            tracker.addEvent(event);
-          }
-        }
-        setEventQueue([]); // Clear the queue
-      }
-    }).catch(error => {
-      logError('Failed to initialize HumanBehaviorTracker:', error);
-    });
-  }, [isMounted, humanBehavior]); // Removed apiKey, client, eventQueue from dependencies
-
-  // Memoized context value to prevent unnecessary re-renders
-  const contextValue = useMemo(() => {
-    if (!isMounted) {
-      return null;
-    }
-    
-    if (!isInitialized) {
-      return null;
-    }
-    
-    return humanBehavior;
-  }, [isMounted, isInitialized, humanBehavior]);
-
-  // If not in browser, render children without context
-  if (!(isBrowser())) {
-    return <>{children}</>;
-  }
-
-  return (
-    <HumanBehaviorContext.Provider value={contextValue}>
-      <HumanBehaviorPageView />
-      {children}
-    </HumanBehaviorContext.Provider>
-  );
-};
-
-// Default implementation for when tracker is not available
-const defaultImplementation: HumanBehaviorInterface = {
-  addEvent: () => {},
-  identifyUser: async ({ userProperties }: { userProperties: Record<string, any> }) => {
-    return '';
-  },
-  start: () => {},
-  stop: () => {},
-  logout: () => {},
-  viewLogs: () => {},
-};
-
-// Memoized queuing implementation for initialization period
-const createQueuingImplementation = (queueEvent: (event: any) => void): HumanBehaviorInterface => ({
-  addEvent: (event: any) => {
-    queueEvent(event);
-  },
-  identifyUser: async ({ userProperties }: { userProperties: Record<string, any> }) => {
-    queueEvent({
-      type: 'identify',
-      userProperties,
-    });
-    return ''; // Return empty string to match interface
-  },
-  start: () => {
-    // Start will be called automatically when initialized
-  },
-  stop: () => {
-    // Stop is a no-op when not initialized
-  },
-  logout: () => {
-    // Logout is a no-op when not initialized
-  },
-  viewLogs: () => {
-    logWarn('Logs are not available until HumanBehaviorTracker is initialized');
-  }
-});
-
-export const useHumanBehavior = () => {
-  const tracker = useContext(HumanBehaviorContext);
-  if (!tracker) {
-    throw new Error('useHumanBehavior must be used within a HumanBehaviorProvider');
-  }
-  return tracker;
-};
-
-// Custom hook for managing unredaction fields dynamically
-export const useRedaction = () => {
-  const tracker = useHumanBehavior();
-  
-  const setUnredactedFields = useCallback((fields: string[]) => {
-    tracker.setUnredactedFields(fields);
-  }, [tracker]);
-  
-  const hasUnredactedFields = useCallback(() => {
-    return tracker.hasUnredactedFields();
-  }, [tracker]);
-  
-  const getUnredactedFields = useCallback(() => {
-    return tracker.getUnredactedFields();
-  }, [tracker]);
-  
-  return {
-    setUnredactedFields,
-    hasUnredactedFields,
-    getUnredactedFields
-  };
-};
-
-// Custom hook for managing user info
-export const useUserTracking = () => {
-  const tracker = useHumanBehavior();
-  
-  const identifyUser = useCallback(async ({ userProperties }: { userProperties: Record<string, any> }) => {
-    try {
-      await tracker.identifyUser({ userProperties });
-      return { success: true };
-    } catch (error) {
-      logError('Failed to identify user:', error);
-      return { success: false, error };
-    }
-  }, [tracker]);
-  
-  return {
-    identifyUser
-  };
-};
-
-// Automatic page tracking component
-function HumanBehaviorPageView() {
-  const tracker = useContext(HumanBehaviorContext);
-
-  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 };

package/src/redact.ts

@@ -1,327 +0,0 @@
-// Simplified redaction functionality for HumanBehavior SDK
-// Since rrweb auto-redacts all input fields by default, this module only handles
-// selectively unredacting specific fields (except passwords which remain protected)
-
-import { logDebug, logWarn } from './utils/logger';
-
-// Check if we're in a browser environment
-const isBrowser = typeof window !== 'undefined';
-
-export interface RedactionOptions {
-    redactedText?: string;
-    excludeSelectors?: string[];
-    userFields?: string[]; // Fields that the user wants to unredact (legacy)
-    redactionStrategy?: {
-        mode: 'privacy-first' | 'visibility-first';
-        unredactFields?: string[]; // Fields to make visible (when mode: 'privacy-first')
-        redactFields?: string[];   // Fields to hide (when mode: 'visibility-first')
-    };
-    legacyRedactFields?: string[]; // For backward compatibility
-}
-
-export class RedactionManager {
-    private redactedText: string = '[REDACTED]';
-    private unredactedFields: Set<string> = new Set(); // Fields that user wants to unredact
-    private redactedFields: Set<string> = new Set(); // Fields that user wants to redact
-    private redactionMode: 'privacy-first' | 'visibility-first' = 'privacy-first';
-    private excludeSelectors: string[] = [
-        '[data-no-redact="true"]',
-        '.human-behavior-no-redact'
-    ];
-
-    constructor(options?: RedactionOptions) {
-        if (options?.redactedText) {
-            this.redactedText = options.redactedText;
-        }
-        if (options?.excludeSelectors) {
-            this.excludeSelectors = [...this.excludeSelectors, ...options.excludeSelectors];
-        }
-        
-        // Handle new redaction strategy
-        if (options?.redactionStrategy) {
-            this.redactionMode = options.redactionStrategy.mode;
-            
-            if (this.redactionMode === 'privacy-first') {
-                // Privacy-first: everything redacted by default, unredact specific fields
-                if (options.redactionStrategy.unredactFields) {
-                    this.setFieldsToUnredact(options.redactionStrategy.unredactFields);
-                }
-            } else {
-                // Visibility-first: everything visible by default, redact specific fields
-                if (options.redactionStrategy.redactFields) {
-                    this.setFieldsToRedact(options.redactionStrategy.redactFields);
-                }
-            }
-        }
-        
-        // Handle legacy redactFields (backward compatibility)
-        if (options?.legacyRedactFields) {
-            this.setFieldsToUnredact(options.legacyRedactFields);
-        }
-        
-        // Handle legacy userFields
-        if (options?.userFields) {
-            this.setFieldsToUnredact(options.userFields);
-        }
-    }
-
-    /**
-     * Set specific fields to be redacted (for visibility-first mode)
-     * @param fields Array of CSS selectors for fields to redact
-     */
-    public setFieldsToRedact(fields: string[]): void {
-        this.redactedFields.clear();
-        
-        // Always include password fields in redacted list
-        const passwordFields = [
-            'input[type="password"]',
-            'input[type="password" i]',
-            '[type="password"]',
-            '[type="password" i]'
-        ];
-        
-        // Add password fields and user-specified fields
-        [...passwordFields, ...fields].forEach(field => {
-            this.redactedFields.add(field);
-        });
-        
-        if (this.redactedFields.size > 0) {
-            logDebug(`Redaction: Active for ${this.redactedFields.size} field(s):`, Array.from(this.redactedFields));
-        } else {
-            logDebug('Redaction: No fields to redact');
-        }
-        
-        this.applyRedactionClasses();
-    }
-
-    /**
-     * Set specific fields to be unredacted (everything else stays redacted by rrweb)
-     * @param fields Array of CSS selectors for fields to unredact
-     */
-    public setFieldsToUnredact(fields: string[]): void {
-        this.unredactedFields.clear();
-        
-        // Filter out password fields (they cannot be unredacted)
-        const validFields = fields.filter(field => {
-            const isPasswordField = this.isPasswordSelector(field);
-            if (isPasswordField) {
-                logWarn(`Cannot unredact password field: ${field} - Password fields are always protected`);
-                return false;
-            }
-            return true;
-        });
-        
-        validFields.forEach(field => this.unredactedFields.add(field));
-        
-        if (validFields.length > 0) {
-            logDebug(`Unredaction: Active for ${validFields.length} field(s):`, validFields);
-        } else {
-            logDebug('Unredaction: No valid fields to unredact');
-        }
-        
-        this.applyUnredactionClasses();
-    }
-
-    /**
-     * Remove specific fields from unredaction (they become redacted again)
-     * @param fields Array of CSS selectors for fields to redact
-     */
-    public redactFields(fields: string[]): void {
-        fields.forEach(field => {
-            this.unredactedFields.delete(field);
-        });
-        
-        if (this.unredactedFields.size > 0) {
-            logDebug(`Unredaction: Removed ${fields.length} field(s), ${this.unredactedFields.size} remaining:`, Array.from(this.unredactedFields));
-        } else {
-            logDebug('Unredaction: All fields redacted');
-        }
-        
-        this.applyUnredactionClasses();
-    }
-
-    /**
-     * Clear all unredacted fields (everything becomes redacted again)
-     */
-    public clearUnredactedFields(): void {
-        this.unredactedFields.clear();
-        logDebug('Unredaction: All fields cleared, everything redacted');
-        
-        this.removeUnredactionClasses();
-    }
-
-    /**
-     * Check if any fields are currently unredacted
-     */
-    public hasUnredactedFields(): boolean {
-        return this.unredactedFields.size > 0;
-    }
-
-    /**
-     * Get the current redaction mode
-     */
-    public getRedactionMode(): 'privacy-first' | 'visibility-first' {
-        return this.redactionMode;
-    }
-
-    /**
-     * Get the currently unredacted fields
-     */
-    public getUnredactedFields(): string[] {
-        return Array.from(this.unredactedFields);
-    }
-
-    /**
-     * Get CSS selectors for rrweb masking configuration
-     * Returns null if no fields are unredacted (everything stays redacted)
-     */
-    public getMaskTextSelector(): string | null {
-        if (this.redactionMode === 'privacy-first') {
-            // Privacy-first: mask everything except unredacted fields
-            if (this.unredactedFields.size === 0) {
-                return null; // Everything stays redacted
-            }
-            return Array.from(this.unredactedFields).join(',');
-        } else {
-            // Visibility-first: mask only redacted fields
-            if (this.redactedFields.size === 0) {
-                return null; // Nothing to redact
-            }
-            return Array.from(this.redactedFields).join(',');
-        }
-    }
-
-    /**
-     * Apply redaction classes to DOM elements (for visibility-first mode)
-     * Adds 'rr-mask' class to elements that should be redacted
-     */
-    public applyRedactionClasses(): void {
-        if (this.redactedFields.size === 0) {
-            return;
-        }
-
-        // Add 'rr-mask' class to redacted elements
-        this.redactedFields.forEach(selector => {
-            try {
-                const elements = document.querySelectorAll(selector);
-                elements.forEach(element => {
-                    element.classList.add('rr-mask');
-                });
-                logDebug(`Added rr-mask class to ${elements.length} element(s) for selector: ${selector}`);
-            } catch (e) {
-                logWarn(`Invalid selector: ${selector}`);
-            }
-        });
-    }
-
-    /**
-     * Apply unredaction classes to DOM elements
-     * Removes 'rr-mask' class from elements that should be unredacted
-     */
-    public applyUnredactionClasses(): void {
-        if (this.unredactedFields.size === 0) {
-            return;
-        }
-
-        // Remove 'rr-mask' class from unredacted elements
-        this.unredactedFields.forEach(selector => {
-            try {
-                const elements = document.querySelectorAll(selector);
-                elements.forEach(element => {
-                    element.classList.remove('rr-mask');
-                });
-                logDebug(`Removed rr-mask class from ${elements.length} element(s) for selector: ${selector}`);
-            } catch (e) {
-                logWarn(`Invalid selector: ${selector}`);
-            }
-        });
-    }
-
-    /**
-     * Remove all unredaction classes from DOM elements
-     */
-    public removeUnredactionClasses(): void {
-        // Note: This doesn't add 'rr-mask' classes back - rrweb handles that automatically
-        logDebug('Unredaction classes removed');
-    }
-
-    /**
-     * Check if a selector represents a password field
-     */
-    private isPasswordSelector(selector: string): boolean {
-        const passwordPatterns = [
-            'input[type="password"]',
-            'input[type="password" i]',
-            '[type="password"]',
-            '[type="password" i]'
-        ];
-        
-        return passwordPatterns.some(pattern => 
-            selector.toLowerCase().includes(pattern.toLowerCase().replace(/[\[\]]/g, ''))
-        );
-    }
-
-    /**
-     * Get the original value of an element (for debugging)
-     */
-    public getOriginalValue(element: HTMLElement): string | undefined {
-        if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
-            return element.value;
-        }
-        return undefined;
-    }
-
-    /**
-     * Check if an element is currently unredacted
-     */
-    public isElementUnredacted(element: HTMLElement): boolean {
-        return this.shouldUnredactElement(element);
-    }
-
-    /**
-     * Check if an element should be unredacted
-     */
-    public shouldUnredactElement(element: HTMLElement): boolean {
-        if (this.redactionMode === 'privacy-first') {
-            // Privacy-first: check if element is in unredacted fields
-            if (this.unredactedFields.size === 0) {
-                return false; // Nothing unredacted
-            }
-
-            // Check if any selector matches this element
-            for (const selector of this.unredactedFields) {
-                try {
-                    if (element.matches(selector)) {
-                        return true;
-                    }
-                } catch (e) {
-                    logWarn(`Invalid selector: ${selector}`);
-                }
-            }
-            return false;
-        } else {
-            // Visibility-first: check if element is NOT in redacted fields
-            if (this.redactedFields.size === 0) {
-                return true; // Nothing redacted, everything visible
-            }
-
-            // Check if any selector matches this element
-            for (const selector of this.redactedFields) {
-                try {
-                    if (element.matches(selector)) {
-                        return false; // Element is redacted
-                    }
-                } catch (e) {
-                    logWarn(`Invalid selector: ${selector}`);
-                }
-            }
-            return true; // Element is not redacted
-        }
-    }
-}
-
-// Export a default instance
-export const redactionManager = new RedactionManager();
-
-// Export the class for custom instances
-export default RedactionManager; 

package/src/remix/index.ts

@@ -1,16 +0,0 @@
-import { HumanBehaviorTracker } from '../index.js';
-import type { LoaderFunctionArgs } from '@remix-run/node';
-
-// Remix-specific loader helper
-export function createHumanBehaviorLoader() {
-  return async ({ request }: LoaderFunctionArgs) => {
-    return {
-      ENV: {
-        HUMANBEHAVIOR_API_KEY: process.env.HUMANBEHAVIOR_API_KEY,
-      },
-    };
-  };
-}
-
-// Re-export React components for convenience
-export { HumanBehaviorProvider, useHumanBehavior } from '../react/index.js'; 

package/src/svelte/index.ts

@@ -1,14 +0,0 @@
-import { HumanBehaviorTracker } from '../index.js';
-
-// Create a Svelte store-like interface for HumanBehavior
-export const humanBehaviorStore = {
-  init: (apiKey: string, options?: {
-    ingestionUrl?: string;
-    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-    redactFields?: string[];
-    suppressConsoleErrors?: boolean;
-    recordCanvas?: boolean; // Enable canvas recording with protection
-  }) => {
-    return HumanBehaviorTracker.init(apiKey, options);
-  }
-};