humanbehavior-js 0.4.28 → 0.5.0

package/src/angular/index.ts

@@ -1,79 +0,0 @@
-import { HumanBehaviorTracker } from '../index.js';
-
-// Angular NgModule for legacy Angular applications
-export class HumanBehaviorModule {
-  static forRoot(config: { 
-    apiKey: string;
-    ingestionUrl?: string;
-    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-    redactFields?: string[];
-    suppressConsoleErrors?: boolean;
-    recordCanvas?: boolean; // Enable canvas recording with protection
-  }) {
-    return {
-      ngModule: HumanBehaviorModule,
-      providers: [
-        {
-          provide: 'HUMANBEHAVIOR_API_KEY',
-          useValue: config.apiKey
-        },
-        {
-          provide: HumanBehaviorTracker,
-          useFactory: (apiKey: string) => {
-            return HumanBehaviorTracker.init(apiKey, {
-              ingestionUrl: config.ingestionUrl,
-              logLevel: config.logLevel,
-              redactFields: config.redactFields,
-              suppressConsoleErrors: config.suppressConsoleErrors,
-              recordCanvas: config.recordCanvas, // Pass canvas recording option
-            });
-          },
-          deps: ['HUMANBEHAVIOR_API_KEY']
-        }
-      ]
-    };
-  }
-}
-
-// Angular service for dependency injection
-export class HumanBehaviorService {
-  private tracker: HumanBehaviorTracker;
-
-  constructor(apiKey: string, options?: {
-    ingestionUrl?: string;
-    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-    redactFields?: string[];
-    suppressConsoleErrors?: boolean;
-    recordCanvas?: boolean; // Enable canvas recording with protection
-  }) {
-    this.tracker = HumanBehaviorTracker.init(apiKey, options);
-  }
-
-  // Expose core tracker methods
-  identifyUser(userProperties: Record<string, any>) {
-    return this.tracker.identifyUser({ userProperties });
-  }
-
-  getSessionId() {
-    return this.tracker.getSessionId();
-  }
-
-  setUnredactedFields(fields: string[]) {
-    return this.tracker.setUnredactedFields(fields);
-  }
-
-  getUnredactedFields() {
-    return this.tracker.getUnredactedFields();
-  }
-}
-
-// Helper function for standalone Angular initialization
-export function initializeHumanBehavior(apiKey: string, options?: {
-  ingestionUrl?: string;
-  logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-  redactFields?: string[];
-  suppressConsoleErrors?: boolean;
-  recordCanvas?: boolean; // Enable canvas recording with protection
-}): HumanBehaviorTracker {
-  return HumanBehaviorTracker.init(apiKey, options);
-} 

package/src/api.ts

@@ -1,416 +0,0 @@
-import { logError, logInfo, logDebug, logWarn } from './utils/logger';
-import { getCachedIP, IPInfo } from './utils/ip-detector';
-
-export const MAX_CHUNK_SIZE_BYTES = 1024 * 1024; // 1MB chunk size - more conservative
-
-export function isChunkSizeExceeded(currentChunk: any[], newEvent: any, sessionId: string): boolean {
-    const nextChunkSize = new TextEncoder().encode(JSON.stringify({
-        sessionId,
-        events: [...currentChunk, newEvent]
-    })).length;
-    
-    return nextChunkSize > MAX_CHUNK_SIZE_BYTES;
-}
-
-export function validateSingleEventSize(event: any, sessionId: string): void {
-    const singleEventSize = new TextEncoder().encode(JSON.stringify({
-        sessionId,
-        events: [event]
-    })).length;
-
-    if (singleEventSize > MAX_CHUNK_SIZE_BYTES) {
-        // Instead of throwing, log a warning and suggest reducing event size
-        logWarn(`Single event size (${singleEventSize} bytes) exceeds maximum chunk size (${MAX_CHUNK_SIZE_BYTES} bytes). Consider reducing event data size.`);
-    }
-}
-
-
-
-
-
-export function splitLargeEvent(event: any, sessionId: string): any[] {
-    // ✅ SIMPLE VALIDATION
-    if (!event || typeof event !== 'object') {
-        return [];
-    }
-    
-    const eventSize = new TextEncoder().encode(JSON.stringify({
-        sessionId,
-        events: [event]
-    })).length;
-
-    if (eventSize <= MAX_CHUNK_SIZE_BYTES) {
-        return [event];
-    }
-
-    // If event is too large, try to split it by removing large properties
-    const simplifiedEvent = { ...event };
-    
-    // Remove potentially large properties
-    const largeProperties = ['screenshot', 'html', 'dom', 'fullText', 'innerHTML', 'outerHTML'];
-    largeProperties.forEach(prop => {
-        if (simplifiedEvent[prop]) {
-            delete simplifiedEvent[prop];
-        }
-    });
-
-    // Check if simplified event is now small enough
-    const simplifiedSize = new TextEncoder().encode(JSON.stringify({
-        sessionId,
-        events: [simplifiedEvent]
-    })).length;
-
-    if (simplifiedSize <= MAX_CHUNK_SIZE_BYTES) {
-        return [simplifiedEvent];
-    }
-
-    // If still too large, create a minimal event
-    const minimalEvent = {
-        type: event.type,
-        timestamp: event.timestamp,
-        url: event.url,
-        pathname: event.pathname,
-        // Keep only essential properties
-        ...Object.fromEntries(
-            Object.entries(event).filter(([key, value]) => 
-                !largeProperties.includes(key) && 
-                typeof value !== 'object' && 
-                typeof value !== 'string' || 
-                (typeof value === 'string' && value.length < 1000)
-            )
-        )
-    };
-
-    return [minimalEvent];
-}
-
-export class HumanBehaviorAPI {
-    private apiKey: string;
-    private baseUrl: string;
-
-    constructor({ apiKey, ingestionUrl }: { apiKey: string, ingestionUrl: string }) {
-        this.apiKey = apiKey;
-        this.baseUrl = ingestionUrl;
-    }
-
-    public async init(sessionId: string, userId: string | null) {
-        // Get current page URL and referrer if in browser environment
-        let entryURL = null;
-        let referrer = null;
-        
-        if (typeof window !== 'undefined') {
-            entryURL = window.location.href;
-            referrer = document.referrer;
-        }
-
-        logInfo('API init called with:', { sessionId, userId, entryURL, referrer, baseUrl: this.baseUrl });
-
-        try {
-        const response = await fetch(`${this.baseUrl}/api/ingestion/init`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Referer': referrer || ''
-            },
-            body: JSON.stringify({
-                sessionId: sessionId,
-                endUserId: userId,
-                entryURL: entryURL,
-                referrer: referrer
-            })
-        });
-
-            logInfo('API init response status:', response.status);
-
-        if (!response.ok) {
-                const errorText = await response.text();
-                logError('API init failed:', response.status, errorText);
-                throw new Error(`Failed to initialize ingestion: ${response.statusText} - ${errorText}`);
-        } 
-
-        const responseJson = await response.json();
-            logInfo('API init success:', responseJson);
-        return {
-            sessionId: responseJson.sessionId,
-            endUserId: responseJson.endUserId
-            }
-        } catch (error) {
-            logError('API init error:', error);
-            throw error;
-        }
-    }
-
-    /**
-     * Send IP address information to the server
-     * This is called after successful initialization
-     */
-    public async sendIPInfo(sessionId: string): Promise<void> {
-        try {
-            const ipInfo = await getCachedIP();
-            if (!ipInfo) {
-                logWarn('No IP address available to send');
-                return;
-            }
-
-            logDebug('Sending IP info:', ipInfo);
-
-            const response = await fetch(`${this.baseUrl}/api/ingestion/ip-info`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({
-                    sessionId: sessionId,
-                    clientIP: ipInfo.ip,
-                    ipDetectionMethod: ipInfo.method,
-                    timestamp: ipInfo.timestamp
-                })
-            });
-
-            if (!response.ok) {
-                const errorText = await response.text();
-                logWarn('Failed to send IP info:', response.status, errorText);
-            } else {
-                logDebug('IP info sent successfully');
-            }
-        } catch (error) {
-            logWarn('Error sending IP info:', error);
-        }
-    }
-
-    async sendEvents(events: any[], sessionId: string, userId: string) {
-        // ✅ SIMPLE VALIDATION FOR ALL EVENTS
-        const validEvents = events.filter(event => event && typeof event === 'object');
-        
-        const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.apiKey}`
-            },
-            body: JSON.stringify({
-                sessionId,
-                events: validEvents,
-                endUserId: userId
-            })
-        });
-        
-        if (!response.ok) {
-            throw new Error(`Failed to send events: ${response.statusText}`);
-        }
-    }
-    
-    async sendEventsChunked(events: any[], sessionId: string, userId?: string) {
-        try {
-            const results = [];
-            let currentChunk: any[] = [];
-            
-            for (const event of events) {
-                // ✅ SIMPLE VALIDATION FOR ALL EVENTS
-                if (!event || typeof event !== 'object') {
-                    continue;
-                }
-                
-                if (isChunkSizeExceeded(currentChunk, event, sessionId)) {
-                    // If current chunk is not empty, send it first
-                    if (currentChunk.length > 0) {
-                        const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
-                            method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'Authorization': `Bearer ${this.apiKey}`
-                            },
-                            body: JSON.stringify({
-                                sessionId,
-                                events: currentChunk,
-                                endUserId: userId
-                            })
-                        });
-                        
-                        if (!response.ok) {
-                            throw new Error(`Failed to send events: ${response.statusText}`);
-                        }
-                        
-                        results.push(await response.json());
-                        currentChunk = [];
-                    }
-
-                    // Handle large events by splitting them
-                    const splitEvents = splitLargeEvent(event, sessionId);
-                    
-                    // Start new chunk with the split events
-                    currentChunk = splitEvents;
-                } else {
-                    // Add event to current chunk
-                    currentChunk.push(event);
-                }
-            }
-            
-            // Send any remaining events
-            if (currentChunk.length > 0) {
-                const response = await fetch(`${this.baseUrl}/api/ingestion/events`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.apiKey}`
-                    },
-                    body: JSON.stringify({
-                        sessionId,
-                        events: currentChunk,
-                        endUserId: userId
-                    })
-                });
-                
-                if (!response.ok) {
-                    throw new Error(`Failed to send events: ${response.statusText}`);
-                }
-                
-                results.push(await response.json());
-            }
-            
-            return results.flat();
-        } catch (error) {
-            logError('Error sending events:', error);
-            throw error;
-        }
-    }
-
-    async sendUserData(userId: string, userData: Record<string, any>, sessionId: string) {
-        try {
-            const payload = {
-                userId: userId,
-                userAttributes: userData,
-                sessionId: sessionId,
-                posthogName: userData.email || userData.name || null // Update user name with email
-            };
-            
-            logDebug('Sending user data to server:', payload);
-            
-            const response = await fetch(`${this.baseUrl}/api/ingestion/user`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify(payload)
-            });
-            
-            if (!response.ok) {
-                throw new Error(`Failed to send user data: ${response.statusText} with API key: ${this.apiKey}`);
-            }
-            
-            const result = await response.json();
-            logDebug('Server response:', result);
-            return result;
-        } catch (error) {
-            logError('Error sending user data:', error);
-            throw error;
-        }
-    }
-
-    async sendUserAuth(userId: string, userData: Record<string, any>, sessionId: string, authFields: string[]) {
-        try {
-            const response = await fetch(`${this.baseUrl}/api/ingestion/user/auth`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({
-                    userId: userId,
-                    userAttributes: userData,
-                    sessionId: sessionId,
-                    authFields: authFields
-                })
-            });
-            
-            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);
-            throw error;
-        }
-    }
-
-    public sendBeaconEvents(events: any[], sessionId: string) {
-        // Create JSON payload that matches the server's expected format
-        const payload = {
-            sessionId: sessionId,
-            events: events,
-            endUserId: null, // Beacon doesn't have user context
-            apiKey: this.apiKey // Include API key in body since beacon can't use headers
-        };
-
-        // Convert to Blob for sendBeacon
-        const blob = new Blob([JSON.stringify(payload)], {
-            type: 'application/json'
-        });
-
-        const success = navigator.sendBeacon(
-            `${this.baseUrl}/api/ingestion/events`, 
-            blob
-        );
-
-        return success;
-    }
-
-    async sendCustomEvent(sessionId: string, eventName: string, eventProperties?: Record<string, any>) {
-        logInfo('[SDK] Sending custom event', { sessionId, eventName, eventProperties });
-        try {
-            const response = await fetch(`${this.baseUrl}/api/ingestion/customEvent`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({
-                    sessionId: sessionId,
-                    eventName: eventName,
-                    eventProperties: eventProperties || {}
-                })
-            });
-            logInfo('[SDK] Custom event response', { status: response.status, statusText: response.statusText });
-            if (!response.ok) {
-                const errorText = await response.text();
-                logError('[SDK] Failed to send custom event', { status: response.status, statusText: response.statusText, errorText });
-                throw new Error(`Failed to send custom event: ${response.status} ${response.statusText} - ${errorText}`);
-            }
-            const json = await response.json();
-            logDebug('[SDK] Custom event success', json);
-            return json;
-        } catch (error) {
-            logError('[SDK] Error sending custom event', error, { sessionId, eventName, eventProperties });
-            throw error;
-        }
-    }
-
-    async sendCustomEventBatch(sessionId: string, events: Array<{ eventName: string; eventProperties?: Record<string, any> }>) {
-        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({
-                    sessionId: sessionId,
-                    events: events
-                })
-            });
-            
-            if (!response.ok) {
-                throw new Error(`Failed to send custom event batch: ${response.statusText}`);
-            }
-            
-            return await response.json();
-        } catch (error) {
-            logError('Error sending custom event batch:', error);
-            throw error;
-        }
-    }
-}

package/src/index.ts

@@ -1,35 +0,0 @@
-/**
- * Main entry point for the HumanBehavior SDK
- */
-
-import { HumanBehaviorTracker } from './tracker';
-
-// Export everything from the tracker module
-export * from './tracker';
-
-// Export everything from the API module
-export * from './api';
-
-// Export redaction functionality
-export * from './redact';
-
-// Export property management functionality
-export * from './utils/property-detector';
-export * from './utils/property-manager';
-
-// Export IP detection functionality
-export * from './utils/ip-detector';
-
-// Export logger functionality
-export * from './utils/logger';
-
-// Installation wizard is exported separately to avoid Node.js dependencies in browser bundles
-// Import from 'humanbehavior-js/install-wizard' for Node.js usage
-
-// Note: Default export removed to avoid mixed export warnings
-// Use: import { HumanBehaviorTracker } from 'humanbehavior-js'
-
-// For UMD builds, expose the main class globally
-if (typeof window !== 'undefined') {
-  (window as any).HumanBehaviorTracker = HumanBehaviorTracker;
-}