humanbehavior-js 0.0.4 → 0.0.7

package/dist/types/index.d.ts

@@ -1,3 +1,85 @@
+interface RedactionOptions {
+    redactedText?: string;
+    excludeSelectors?: string[];
+    userFields?: string[];
+}
+declare class RedactionManager {
+    private redactedText;
+    private userSelectedFields;
+    private excludeSelectors;
+    constructor(options?: RedactionOptions);
+    /**
+     * Set specific fields to be redacted
+     * @param fields Array of CSS selectors for fields to redact
+     */
+    setFieldsToRedact(fields: string[]): void;
+    /**
+     * Check if redaction is currently active (has fields selected)
+     */
+    isActive(): boolean;
+    /**
+     * Get the currently selected fields for redaction
+     */
+    getSelectedFields(): string[];
+    /**
+     * Process an event and redact sensitive data if needed
+     */
+    processEvent(event: any): any;
+    /**
+     * Redact sensitive data in input events
+     */
+    private redactInputEvent;
+    /**
+     * Redact sensitive data in DOM mutation events
+     */
+    private redactDOMEvent;
+    /**
+     * Check if a DOM change should be redacted based on its ID
+     */
+    private shouldRedactDOMChange;
+    /**
+     * Redact sensitive data in mouse/touch interaction events
+     */
+    private redactMouseEvent;
+    /**
+     * Redact sensitive data in full snapshot events
+     */
+    private redactFullSnapshot;
+    /**
+     * Recursively redact sensitive data in DOM nodes
+     */
+    private redactNode;
+    /**
+     * Check if a node should be redacted based on its attributes
+     */
+    private shouldRedactNode;
+    /**
+     * Check if a CSS selector would match a node based on its attributes
+     */
+    private selectorMatchesNode;
+    /**
+     * Basic selector matching for environments where matches() is not available
+     */
+    private basicSelectorMatch;
+    /**
+     * Check if an event is from a field that should be redacted
+     */
+    private isFieldSelected;
+    /**
+     * Check if an element should be redacted based on user-selected fields
+     */
+    private shouldRedactElement;
+    /**
+     * Get the original value of a redacted element (for debugging)
+     */
+    getOriginalValue(element: HTMLElement): string | undefined;
+    /**
+     * Check if an element is currently being redacted
+     */
+    isElementRedacted(element: HTMLElement): boolean;
+}
+declare const redactionManager: RedactionManager;
+
 declare global {
     interface Window {
         HumanBehaviorTracker: typeof HumanBehaviorTracker;
@@ -18,13 +100,19 @@ declare class HumanBehaviorTracker {
     private apiKey;
     private initialized;
     initializationPromise: Promise<void> | null;
-    constructor(apiKey: string | undefined);
+    private redactionManager;
+    constructor(apiKey: string | undefined, ingestionUrl: string | undefined);
     private init;
     private ensureInitialized;
     static logToStorage(message: string): void;
     private setupPageUnloadHandler;
     viewLogs(): void;
-    identifyUser(userProperties: Record<string, any>): Promise<void>;
+    addUserInfo(userProperties: Record<string, any>): Promise<void>;
+    /**
+     * Authenticate user using existing userInfo data
+     * @param authFields Array of field names to check for existing users (e.g., ['email', 'phoneNumber'])
+     */
+    auth(authFields: string[]): Promise<void>;
     customEvent(eventName: string, eventProperties?: Record<string, any>): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -33,6 +121,24 @@ declare class HumanBehaviorTracker {
     private flush;
     private setCookie;
     private getCookie;
+    /**
+     * 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
+     * @param fields Array of CSS selectors for fields to redact (e.g., ['input[type="password"]', '#email-field'])
+     */
+    setRedactedFields(fields: string[]): void;
+    /**
+     * Check if redaction is currently active
+     */
+    isRedactionActive(): boolean;
+    /**
+     * Get the currently selected fields for redaction
+     */
+    getRedactedFields(): string[];
 }
 
 declare const MAX_CHUNK_SIZE_BYTES: number;
@@ -41,8 +147,9 @@ declare function validateSingleEventSize(event: any, sessionId: string): void;
 declare class HumanBehaviorAPI {
     private apiKey;
     private baseUrl;
-    constructor({ apiKey }: {
+    constructor({ apiKey, ingestionUrl }: {
         apiKey: string;
+        ingestionUrl: string;
     });
     init(sessionId: string, userId: string | null): Promise<{
         sessionId: any;
@@ -51,6 +158,7 @@ declare class HumanBehaviorAPI {
     sendEvents(events: any[], sessionId: string, userId: string): Promise<void>;
     sendEventsChunked(events: any[], sessionId: string): Promise<any[]>;
     sendUserData(userId: string, userData: Record<string, any>, sessionId: string): Promise<any>;
+    sendUserAuth(userId: string, userData: Record<string, any>, sessionId: string, authFields: string[]): Promise<any>;
     sendSessionComplete(sessionId: string): Promise<void>;
     sendCustomEvent(eventName: string, eventProperties: Record<string, any>, sessionId: string): Promise<any>;
     sendCustomEvents(events: any[], sessionId: string): Promise<any>;
@@ -60,4 +168,5 @@ declare class HumanBehaviorAPI {
     sendBeaconCustomEvents(events: any[], sessionId: string): boolean;
 }
 
-export { HumanBehaviorAPI, HumanBehaviorTracker, MAX_CHUNK_SIZE_BYTES, HumanBehaviorTracker as default, isChunkSizeExceeded, validateSingleEventSize };
+export { HumanBehaviorAPI, HumanBehaviorTracker, MAX_CHUNK_SIZE_BYTES, RedactionManager, HumanBehaviorTracker as default, isChunkSizeExceeded, redactionManager, validateSingleEventSize };
+export type { RedactionOptions };

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

@@ -3,7 +3,7 @@ import { HumanBehaviorTracker } from '..';
 
 interface HumanBehaviorInterface {
     addEvent: (event: any) => void;
-    identifyUser: (userProperties: Record<string, any>) => Promise<void>;
+    addUserInfo: (userProperties: Record<string, any>) => Promise<void>;
     start: () => void;
     stop: () => void;
     viewLogs: () => void;

package/package.json

@@ -1,19 +1,12 @@
 {
   "name": "humanbehavior-js",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "description": "SDK for HumanBehavior session and event recording",
   "type": "module",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
   "unpkg": "dist/index.min.js",
-  "files": [
-    "dist",
-    "react.js",
-    "react.d.ts",
-    "index.js",
-    "index.d.ts"
-  ],
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",
@@ -45,15 +38,11 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@types/cors": "^2.8.17",
-    "@types/express": "^5.0.1",
+    "@types/node": "^24.0.3",
     "rollup": "^4.36.0",
     "rollup-plugin-dts": "^6.2.1",
-    "ts-loader": "^9.5.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.2",
-    "webpack": "^5.98.0",
-    "webpack-cli": "^6.0.1"
+    "typescript": "^5.8.2"
   },
   "publishConfig": {
     "access": "public"

package/rollup.config.js

@@ -0,0 +1,106 @@
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+import dts from 'rollup-plugin-dts';
+
+// Only React should be external since it's typically provided by the host application
+const external = ['react', 'react-dom'];
+
+// Global variables for UMD build
+const globals = {
+  react: 'React',
+  'react-dom': 'ReactDOM'
+};
+
+export default [
+  // Main SDK bundle
+  {
+    input: 'src/index.ts',
+    output: [
+      {
+        file: 'dist/cjs/index.js',
+        format: 'cjs',
+        name: 'HumanBehaviorTracker',
+        globals,
+        exports: 'named',
+        sourcemap: true
+      },
+      {
+        file: 'dist/esm/index.js',
+        format: 'es',
+        sourcemap: true
+      },
+      {
+        file: 'dist/index.min.js',
+        format: 'umd',
+        name: 'HumanBehaviorTracker',
+        globals,
+        exports: 'auto',
+        sourcemap: true,
+        plugins: [terser()]
+      }
+    ],
+    plugins: [
+      resolve(),
+      commonjs(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        declaration: false
+      })
+    ],
+    external
+  },
+  
+  // React component bundle
+  {
+    input: './src/react/index.tsx',
+    output: [
+      {
+        file: 'dist/cjs/react/index.js',
+        format: 'cjs',
+        name: 'HumanBehaviorReact',
+        globals: {
+          ...globals,
+          '..': 'HumanBehaviorTracker'
+        },
+        exports: 'named',
+        sourcemap: true
+      },
+      {
+        file: 'dist/esm/react/index.js',
+        format: 'es',
+        sourcemap: true
+      }
+    ],
+    plugins: [
+      resolve(),
+      commonjs(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        declaration: false
+      })
+    ],
+    external: [...external, '..']
+  },
+  
+  // Type definition bundles - generate these separately
+  {
+    input: 'src/index.ts',
+    output: {
+      file: 'dist/types/index.d.ts',
+      format: 'es'
+    },
+    plugins: [dts()],
+    external
+  },
+  {
+    input: 'src/react/index.tsx',
+    output: {
+      file: 'dist/types/react/index.d.ts',
+      format: 'es'
+    },
+    plugins: [dts()],
+    external: [...external, '..']
+  }
+]; 

package/src/api.ts

@@ -0,0 +1,348 @@
+export const MAX_CHUNK_SIZE_BYTES = 1024 * 1024 * 10; // 10MB chunk size
+
+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) {
+        throw new Error(`Single event size (${singleEventSize} bytes) exceeds maximum chunk size (${MAX_CHUNK_SIZE_BYTES} bytes)`);
+    }
+}
+
+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) {
+        const response = await fetch(`${this.baseUrl}/api/ingestion/init`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                sessionId: sessionId,
+                endUserId: userId
+            })
+        });
+
+        if (!response.ok) {
+            throw new Error(`Failed to initialize ingestion: ${response.statusText}`);
+        } 
+
+        const responseJson = await response.json();
+        return {
+            sessionId: responseJson.sessionId,
+            endUserId: responseJson.endUserId
+        }
+    }
+
+    async sendEvents(events: any[], sessionId: string, userId: string) {
+        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: events,
+                endUserId: userId
+            })
+        });
+        
+        if (!response.ok) {
+            throw new Error(`Failed to send events: ${response.statusText}`);
+        }
+    }
+    
+    async sendEventsChunked(events: any[], sessionId: string) {
+        try {
+            const results = [];
+            let currentChunk: any[] = [];
+            
+            for (const event of events) {
+                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
+                            })
+                        });
+                        
+                        if (!response.ok) {
+                            throw new Error(`Failed to send events: ${response.statusText}`);
+                        }
+                        
+                        results.push(await response.json());
+                        currentChunk = [];
+                    }
+
+                    // Validate single event size
+                    validateSingleEventSize(event, sessionId);
+                    
+                    // Start new chunk with this event
+                    currentChunk = [event];
+                } 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
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`Failed to send events: ${response.statusText}`);
+                }
+                
+                results.push(await response.json());
+            }
+            
+            return results.flat();
+        } catch (error) {
+            console.error('Error sending events:', error);
+            throw error;
+        }
+    }
+
+    async sendUserData(userId: string, userData: Record<string, any>, sessionId: string) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/ingestion/user`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    userId: userId,
+                    userAttributes: userData,
+                    sessionId: sessionId
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error(`Failed to send user data: ${response.statusText} with API key: ${this.apiKey}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('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}`);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Error authenticating user:', error);
+            throw error;
+        }
+    }
+
+    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) {
+                    console.error('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) {
+                    console.error('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) {
+        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) {
+            console.log('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/index.ts

@@ -0,0 +1,22 @@
+/**
+ * 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';
+
+// Also export the tracker as the default export
+export { HumanBehaviorTracker as default } from './tracker';
+
+// For UMD builds, expose the main class globally
+if (typeof window !== 'undefined') {
+  (window as any).HumanBehaviorTracker = HumanBehaviorTracker;
+}