cryptique-sdk 1.2.20 → 1.2.21

package/lib/esm/index.js

@@ -90,8 +90,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
 
     // Geolocation API
     GEOLOCATION: {
-      PRIMARY_URL: "https://ipinfo.io/json?token=8fc6409059aa39",
-      BACKUP_URL: "https://ipinfo.io/json?token=8fc6409059aa39&http=1.1",
+      PRIMARY_URL: "https://ipinfo.io/json?token=3a0c034aefbef8",
+      BACKUP_URL: "https://ipinfo.io/json?token=3a0c034aefbef8&http=1.1",
       TIMEOUT_MS: 5000                                  // 5 second timeout
     },
 
@@ -1137,7 +1137,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     isFirstPage: true,
     
     // JSONB fields
-    interactions: {},
     visited_pages: [],
     
     // Also stored in locationData object for structured access (backward compatibility)
@@ -2082,7 +2081,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       if (sessionData.utm_id === undefined) sessionData.utm_id = null;
       
       // JSONB fields
-      if (!sessionData.interactions) sessionData.interactions = {};
       if (!sessionData.visited_pages) sessionData.visited_pages = [];
       
       // Internal tracking
@@ -2147,8 +2145,7 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         // UTM fields (already snake_case, no mapping needed)
         
         // JSONB fields
-        'visited_pages': 'visited_pages',  // Already snake_case
-        'interactions': 'interactions'     // Already snake_case
+        'visited_pages': 'visited_pages'   // Already snake_case
       };
       
       return fieldMap[internalName] || this.toSnakeCase(internalName);
@@ -3192,333 +3189,24 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
     }
   };
 
-  // ============================================================================
-  // SECTION 10: INTERACTION MANAGEMENT
-  // ============================================================================
-  // PURPOSE: Single source of truth for interaction tracking and management.
-  //          Handles all user interactions (clicks, forms, scroll, hover, etc.)
-  //
-  // KEY PRINCIPLES:
-  // 1. All interactions stored in categorized structure
-  // 2. Automatic timestamp addition
-  // 3. Total interactions count maintained
-  // 4. Chronological sorting for backend
-  // 5. Immediate session storage updates
-  // 6. Prevents duplicate interactions
-  //
-  // BENEFITS:
-  // - Centralized interaction tracking
-  // - Consistent data structure
-  // - Single place to fix interaction bugs
-  // - Prevents repeating interactions
-  // ============================================================================
+  // SECTION 10: INTERACTION MANAGEMENT — REMOVED
+  // Interactions JSONB tracking has been removed from sessions.
+  // Important signals (clicks, errors, etc.) are captured as individual
+  // queryable auto events in the events table instead.
 
-  /**
-   * InteractionManager - Interaction tracking and management
-   * 
-   * This object handles all user interaction tracking, storage, and management
-   */
+  // No-op stub — all methods removed with interactions feature.
   const InteractionManager = {
-    /**
-     * Interaction categories
-     * 
-     * All supported interaction categories
-     */
-    CATEGORIES: [
-      'clicks',
-      'formInteractions',
-      'mediaInteractions',
-      'scrollEvents',
-      'focusEvents',
-      'hoverEvents',
-      'formSubmissions',
-      'fieldChanges',
-      'validationErrors',
-      'keyboardEvents',
-      'copyPasteEvents',
-      'contextMenuEvents',
-      'dragDropEvents',
-      'touchEvents',
-      'windowEvents',
-      'performanceEvents',
-      'errorEvents',
-      'networkEvents',
-      'formAnalytics'
-    ],
-
-    /**
-     * Initialize interactions structure
-     * 
-     * Creates empty interactions object with all categories
-     */
-    initialize() {
-      if (!sessionData.interactions || Object.keys(sessionData.interactions).length === 0) {
-        sessionData.interactions = {
-          totalInteractions: 0,
-          clicks: [],
-          formInteractions: [],
-          mediaInteractions: [],
-          scrollEvents: [],
-          focusEvents: [],
-          hoverEvents: [],
-          formSubmissions: [],
-          fieldChanges: [],
-          validationErrors: [],
-          keyboardEvents: [],
-          copyPasteEvents: [],
-          contextMenuEvents: [],
-          dragDropEvents: [],
-          touchEvents: [],
-          windowEvents: [],
-          performanceEvents: [],
-          errorEvents: [],
-          networkEvents: [],
-          formAnalytics: []
-        };
-      }
-    },
-
-    /**
-     * Add interaction to appropriate category
-     * 
-     * Logic:
-     * 1. Ensures interactions are initialized
-     * 2. Adds timestamp if not provided
-     * 3. Adds to specific category array
-     * 4. Updates total interactions count
-     * 5. Updates session activity
-     * 6. Immediately updates session storage
-     * 
-     * Parameters:
-     * - category: Interaction category (e.g., 'clicks', 'formInteractions')
-     * - interactionData: Interaction data object
-     */
-    add(category, interactionData) {
-      // Ensure interactions are initialized
-      this.initialize();
-
-      // Validate category
-      if (!this.CATEGORIES.includes(category)) {
-        return;
-      }
-
-      // Add timestamp if not provided
-      if (!interactionData.timestamp) {
-        interactionData.timestamp = nowIso();
-      }
-
-      // Add to specific category
-      if (sessionData.interactions[category]) {
-        sessionData.interactions[category].push(interactionData);
-      }
-
-      // Update total interactions count
-      this.updateTotalCount();
-
-      // Update last activity
-      sessionData.lastActivity = Date.now();
-
-      // Immediately update session storage
-      this.updateSessionStorage();
-    },
-
-    /**
-     * Update total interactions count
-     * 
-     * Calculates total from all category arrays
-     */
-    updateTotalCount() {
-      if (!sessionData.interactions) return;
-
-      let total = 0;
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          total += sessionData.interactions[category].length;
-        }
-      }
-
-      sessionData.interactions.totalInteractions = total;
-    },
-
-    /**
-     * Update session storage with interactions
-     * 
-     * Immediately syncs interactions to session storage
-     */
-    updateSessionStorage() {
-      try {
-        const storedSession = StorageManager.loadSession();
-        if (storedSession && storedSession.sessionData) {
-          storedSession.sessionData.interactions = sessionData.interactions;
-          StorageManager.saveSession(storedSession);
-        }
-      } catch (error) {
-        }
-    },
-
-    /**
-     * Get all interactions sorted chronologically
-     * 
-     * Collects all interactions from all categories, adds category identifiers,
-     * and sorts by timestamp
-     * 
-     * Returns: Array of interactions sorted by timestamp
-     */
-    getChronological() {
-      if (!sessionData.interactions) {
-        return [];
-      }
-
-      const allInteractions = [];
-
-      // Map of category to category identifier
-      const categoryMap = {
-        'clicks': { category: 'click', originalCategory: 'clicks' },
-        'formInteractions': { category: 'formInteraction', originalCategory: 'formInteractions' },
-        'mediaInteractions': { category: 'mediaInteraction', originalCategory: 'mediaInteractions' },
-        'scrollEvents': { category: 'scrollEvent', originalCategory: 'scrollEvents' },
-        'focusEvents': { category: 'focusEvent', originalCategory: 'focusEvents' },
-        'hoverEvents': { category: 'hoverEvent', originalCategory: 'hoverEvents' },
-        'formSubmissions': { category: 'formSubmission', originalCategory: 'formSubmissions' },
-        'fieldChanges': { category: 'fieldChange', originalCategory: 'fieldChanges' },
-        'validationErrors': { category: 'validationError', originalCategory: 'validationErrors' },
-        'keyboardEvents': { category: 'keyboardEvent', originalCategory: 'keyboardEvents' },
-        'copyPasteEvents': { category: 'copyPasteEvent', originalCategory: 'copyPasteEvents' },
-        'contextMenuEvents': { category: 'contextMenuEvent', originalCategory: 'contextMenuEvents' },
-        'dragDropEvents': { category: 'dragDropEvent', originalCategory: 'dragDropEvents' },
-        'touchEvents': { category: 'touchEvent', originalCategory: 'touchEvents' },
-        'windowEvents': { category: 'windowEvent', originalCategory: 'windowEvents' },
-        'performanceEvents': { category: 'performanceEvent', originalCategory: 'performanceEvents' },
-        'errorEvents': { category: 'errorEvent', originalCategory: 'errorEvents' },
-        'networkEvents': { category: 'networkEvent', originalCategory: 'networkEvents' },
-        'formAnalytics': { category: 'formAnalytic', originalCategory: 'formAnalytics' }
-      };
-
-      // Collect all interactions from all categories
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          const categoryInfo = categoryMap[category];
-          sessionData.interactions[category].forEach(interaction => {
-            allInteractions.push({
-              ...interaction,
-              category: categoryInfo.category,
-              originalCategory: categoryInfo.originalCategory
-            });
-          });
-        }
-      }
-
-      // Sort by timestamp (chronological order)
-      allInteractions.sort((a, b) => {
-        const timestampA = new Date(a.timestamp || 0);
-        const timestampB = new Date(b.timestamp || 0);
-        return timestampA - timestampB;
-      });
-
-      return allInteractions;
-    },
-
-    /**
-     * Get chronological interactions for backend
-     * 
-     * Returns both chronological array and categorized structure
-     * 
-     * Returns: Object with chronological and categorized interactions
-     */
-    getChronologicalForBackend() {
-      const chronological = this.getChronological();
-
-      return {
-        chronological: chronological,
-        categorized: sessionData.interactions
-      };
-    },
-
-    /**
-     * Deduplicate interactions
-     * 
-     * Removes duplicate interactions based on timestamp, category, and key fields
-     * 
-     * Logic:
-     * - Compares interactions by timestamp, category, and element identifier
-     * - Keeps first occurrence of duplicates
-     * - Updates total count after deduplication
-     */
-    deduplicate() {
-      if (!sessionData.interactions) return;
-
-      const seen = new Set();
-
-      for (const category of this.CATEGORIES) {
-        if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-          sessionData.interactions[category] = sessionData.interactions[category].filter(interaction => {
-            // Create unique key from timestamp, category, and element identifier
-            const elementId = interaction.elementId || interaction.target || interaction.selector || '';
-            const key = `${interaction.timestamp}_${category}_${elementId}`;
-
-            if (seen.has(key)) {
-              return false; // Duplicate, remove
-            }
-
-            seen.add(key);
-            return true; // Keep
-          });
-        }
-      }
-
-      // Update total count after deduplication
-      this.updateTotalCount();
-
-      // Update session storage
-      this.updateSessionStorage();
-    },
-
-    /**
-     * Get interactions by category
-     * 
-     * Returns all interactions for a specific category
-     * 
-     * Parameters: category - Interaction category name
-     * Returns: Array of interactions for that category
-     */
-    getByCategory(category) {
-      if (!sessionData.interactions) {
-        return [];
-      }
-
-      if (!this.CATEGORIES.includes(category)) {
-        return [];
-      }
-
-      return sessionData.interactions[category] || [];
-    },
-
-    /**
-     * Get total interactions count
-     * 
-     * Returns total number of interactions across all categories
-     */
-    getTotalCount() {
-      if (!sessionData.interactions) {
-        return 0;
-      }
-
-      return sessionData.interactions.totalInteractions || 0;
-    },
-
-    /**
-     * Clear all interactions
-     * 
-     * Resets interactions object to empty state
-     */
-    clear() {
-      this.initialize();
-      for (const category of this.CATEGORIES) {
-        sessionData.interactions[category] = [];
-      }
-      sessionData.interactions.totalInteractions = 0;
-      this.updateSessionStorage();
-    }
+    CATEGORIES: [],
+    initialize() {},
+    add() {},
+    updateTotalCount() {},
+    updateSessionStorage() {},
+    getChronological() { return []; },
+    getChronologicalForBackend() { return { chronological: [], categorized: {} }; },
+    deduplicate() {},
+    getByCategory() { return []; },
+    getTotalCount() { return 0; },
+    clear() {}
   };
 
   // ============================================================================
@@ -3986,7 +3674,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       // Ensure arrays exist
       s.pageVisits = s.pageVisits || [];
       s.visited_pages = s.visited_pages || [];
-      s.interactions = s.interactions || { totalInteractions: 0 };
       
       // Normalize timestamps to ISO strings
       if (s.startTime && !(typeof s.startTime === 'string')) {
@@ -4041,171 +3728,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       // First normalize the shape
       sourceData = this.normalizeShape(sourceData);
       
-      // Get chronological interactions
-      const chronologicalInteractions = InteractionManager.getChronologicalForBackend();
-      
-      // Get page visits and session-level interactions
+      // Get page visits
       const pageVisits = sourceData.visited_pages || sourceData.pageVisits || sourceData.visitedPages || [];
-      const sessionInteractions = sourceData.interactions || {};
-      
-      // CRITICAL FIX: Distribute session-level interactions to appropriate pages based on path
-      const interactionTypes = [
-        'clicks', 'mediaInteractions', 'contextMenuEvents', 'windowEvents',
-        'formInteractions', 'scrollEvents', 'focusEvents', 'hoverEvents',
-        'formSubmissions', 'fieldChanges',
-        'keyboardEvents', 'copyPasteEvents', 'dragDropEvents',
-        'touchEvents', 'formAnalytics'
-        // Note: validationErrors, performanceEvents, errorEvents, networkEvents are no longer
-        // stored in session interactions — they are emitted as individual queryable auto events
-        // (form_validation_error, page_performance, js_error, network_error)
-      ];
-      
-      // Helper to normalize path for matching
-      const normalizePathForMatching = (path) => {
-        if (!path) return '/';
-        // Remove query params and hash
-        const cleanPath = path.split('?')[0].split('#')[0];
-        return cleanPath || '/';
-      };
-      
-      // Get session start time in milliseconds for alignment
-      const sessionStartTime = sourceData.start_time || sourceData.startTime;
-      const sessionStartMs = sessionStartTime 
-        ? (typeof sessionStartTime === 'string' ? new Date(sessionStartTime).getTime() : sessionStartTime)
-        : Date.now();
-      
-      // Distribute interactions to pages and fix mount/unmount times
-      // CRITICAL: Create copies to avoid mutating original objects
-      const pagesWithInteractions = pageVisits.map((pageVisit, index) => {
-        // Create a copy of the page visit to avoid mutating the original
-        const pageVisitCopy = { ...pageVisit };
-        const pagePath = normalizePathForMatching(pageVisitCopy.path || pageVisitCopy.url);
-        const isFirstPage = index === 0 || pageVisitCopy.isEntry === true;
-        
-        // CRITICAL FIX: If unmountTime is null, set it to next page's mountTime
-        if (!pageVisitCopy.unmountTime && index < pageVisits.length - 1) {
-          const nextPage = pageVisits[index + 1];
-          if (nextPage && nextPage.mountTime) {
-            pageVisitCopy.unmountTime = typeof nextPage.mountTime === 'number' 
-              ? nextPage.mountTime 
-              : new Date(nextPage.mountTime).getTime();
-            // Recalculate duration
-            if (pageVisitCopy.mountTime) {
-              const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                ? pageVisitCopy.mountTime
-                : new Date(pageVisitCopy.mountTime).getTime();
-              pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-            }
-          }
-        }
-        
-        // If still no unmountTime and this is the last page, set to session endTime
-        if (!pageVisitCopy.unmountTime && index === pageVisits.length - 1) {
-          const endTime = sourceData.end_time || sourceData.endTime;
-          if (endTime) {
-            pageVisitCopy.unmountTime = typeof endTime === 'number'
-              ? endTime
-              : new Date(endTime).getTime();
-            // Recalculate duration
-            if (pageVisitCopy.mountTime) {
-              const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                ? pageVisitCopy.mountTime
-                : new Date(pageVisitCopy.mountTime).getTime();
-              pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-            }
-          }
-        }
-        
-        // FIX: Align first page mountTime with session start_time (only in copy, not original)
-        if (isFirstPage && pageVisitCopy.mountTime) {
-          const mountTimeMs = typeof pageVisitCopy.mountTime === 'number' 
-            ? pageVisitCopy.mountTime 
-            : new Date(pageVisitCopy.mountTime).getTime();
-          
-          // If mountTime is more than 5 minutes off from session start, align it
-          const timeDiff = Math.abs(mountTimeMs - sessionStartMs);
-          if (timeDiff > 5 * 60 * 1000) { // More than 5 minutes difference
-            pageVisitCopy.mountTime = sessionStartMs;
-            // Recalculate duration if unmountTime exists
-            if (pageVisitCopy.unmountTime) {
-              const unmountTimeMs = typeof pageVisitCopy.unmountTime === 'number'
-                ? pageVisitCopy.unmountTime
-                : new Date(pageVisitCopy.unmountTime).getTime();
-              pageVisitCopy.duration = Math.floor((unmountTimeMs - sessionStartMs) / 1000);
-            }
-          }
-        }
-        
-        // Ensure mountTime and unmountTime are numbers (milliseconds) for consistency (in copy only)
-        if (pageVisitCopy.mountTime && typeof pageVisitCopy.mountTime !== 'number') {
-          pageVisitCopy.mountTime = new Date(pageVisitCopy.mountTime).getTime();
-        }
-        if (pageVisitCopy.unmountTime && typeof pageVisitCopy.unmountTime !== 'number') {
-          pageVisitCopy.unmountTime = new Date(pageVisitCopy.unmountTime).getTime();
-        }
-        
-        // Initialize interactions object for this page if it doesn't exist (in copy)
-        if (!pageVisitCopy.interactions) {
-          pageVisitCopy.interactions = {
-            totalInteractions: 0,
-            clicks: [],
-            mediaInteractions: [],
-            contextMenuEvents: [],
-            windowEvents: [],
-            formInteractions: [],
-            scrollEvents: [],
-            focusEvents: [],
-            hoverEvents: [],
-            formSubmissions: [],
-            fieldChanges: [],
-            validationErrors: [],
-            keyboardEvents: [],
-            copyPasteEvents: [],
-            dragDropEvents: [],
-            touchEvents: [],
-            performanceEvents: [],
-            errorEvents: [],
-            networkEvents: [],
-            formAnalytics: []
-          };
-        }
-        
-        // Distribute interactions from session-level to this page based on path matching (in copy)
-        interactionTypes.forEach(type => {
-          if (Array.isArray(sessionInteractions[type])) {
-            sessionInteractions[type].forEach(interaction => {
-              const interactionPath = normalizePathForMatching(interaction.path);
-              if (interactionPath === pagePath) {
-                // Add interaction to this page (avoid duplicates)
-                const exists = pageVisitCopy.interactions[type].some(existing => {
-                  // Check for duplicates based on timestamp and key properties
-                  if (existing.timestamp && interaction.timestamp) {
-                    return existing.timestamp === interaction.timestamp;
-                  }
-                  // For clicks, check element properties
-                  if (type === 'clicks' && existing.element && interaction.element) {
-                    return existing.element.id === interaction.element.id &&
-                           existing.element.tagName === interaction.element.tagName;
-                  }
-                  return false;
-                });
-                
-                if (!exists) {
-                  pageVisitCopy.interactions[type].push(interaction);
-                }
-              }
-            });
-          }
-        });
-        
-        // Calculate totalInteractions for this page (in copy)
-        const total = interactionTypes.reduce((sum, type) => {
-          return sum + (pageVisitCopy.interactions[type]?.length || 0);
-        }, 0);
-        pageVisitCopy.interactions.totalInteractions = total;
-        
-        return pageVisitCopy;
-      });
       
       // Create transformed object - PostgreSQL snake_case format only
       const transformed = {
@@ -4270,12 +3794,8 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         utm_content: sourceData.utm_content || sourceData.utmData?.content || null,
         utm_id: sourceData.utm_id || sourceData.utmData?.utm_id || null,
         
-        // JSONB fields - NOW WITH INTERACTIONS DISTRIBUTED TO PAGES
-        visited_pages: pagesWithInteractions,
-        interactions: {
-          ...sessionInteractions,
-          chronological: chronologicalInteractions.chronological || []
-        },
+        // JSONB fields
+        visited_pages: pageVisits,
 
         // Active tab time in ms (tab foreground time only, for active_time_seconds in DB)
         active_time_ms: sourceData.active_time_ms || null
@@ -4943,12 +4463,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
             if (hoveredElements.has(elementId)) {
               hoveredElements.delete(elementId);
               
-              // Update hover duration in the interaction
-              const interactions = InteractionManager.getByCategory('hoverEvents');
-              const hoverEvent = interactions.find(h => h.elementId === elementId);
-              if (hoverEvent) {
-                hoverEvent.hoverDuration = Date.now() - new Date(hoverEvent.timestamp).getTime();
-              }
             }
           }
         });
@@ -6267,9 +5781,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
         // Initialize session data structure
         SessionDataManager.initialize(sessionId, userId);
         
-        // Initialize interactions
-        InteractionManager.initialize();
-        
         // Initialize page visits
         PageVisitManager.initialize();
       } catch (error) {
@@ -6412,15 +5923,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 sessionData.pagesViewed = sessionData.visited_pages.length;
               }
 
-              // Sync interactions
-              if (storedSession.sessionData.interactions) {
-                const storedInteractions = storedSession.sessionData.interactions;
-                if (storedInteractions.totalInteractions > 
-                    (sessionData.interactions?.totalInteractions || 0)) {
-                  // Update interactions from storage
-                  sessionData.interactions = storedInteractions;
-                }
-              }
             }
 
             // Update endTime
@@ -6483,9 +5985,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
                 }));
                 sessionData.pagesViewed = sessionData.visited_pages.length;
               }
-              if (storedSession.sessionData.interactions) {
-                sessionData.interactions = storedSession.sessionData.interactions;
-              }
             }
 
             // Track browser close (last page unmount)
@@ -8668,10 +8167,6 @@ if (window.Cryptique && window.Cryptique.initialized) ; else {
       return sessionData;
     },
     
-    // Interaction Functions
-    getChronologicalInteractions: InteractionManager.getChronological.bind(InteractionManager),
-    sortInteractionsChronologically: InteractionManager.getChronological.bind(InteractionManager),
-    
     // Auto Events Configuration
     enableAutoEvents: function() {
       CONFIG.AUTO_EVENTS.enabled = true;