mixpanel-browser 2.77.0 → 2.78.0

package/dist/mixpanel-with-recorder.js

@@ -28,7 +28,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.77.0'
+        LIB_VERSION: '2.78.0'
     };
 
     // Window global names for async modules
@@ -25663,7 +25663,9 @@
         }
 
         this.flags = null;
-        this.fetchFlags();
+        this.fetchFlags().catch(function() {
+            logger$1.error('Error fetching flags during init');
+        });
 
         this.trackedFeatures = new Set();
         this.pendingFirstTimeEvents = {};
@@ -25704,8 +25706,12 @@
         var oldContext = (options && options['replace']) ? {} : this.getConfig(CONFIG_CONTEXT);
         ffConfig[CONFIG_CONTEXT] = _.extend({}, oldContext, newContext);
 
-        this.setMpConfig(FLAGS_CONFIG_KEY, ffConfig);
-        return this.fetchFlags();
+        var configUpdate = {};
+        configUpdate[FLAGS_CONFIG_KEY] = ffConfig;
+        this.setMpConfig(configUpdate);
+        return this.fetchFlags().catch(function() {
+            logger$1.error('Error fetching flags during updateContext');
+        });
     };
 
     FeatureFlagManager.prototype.areFlagsReady = function() {
@@ -25742,96 +25748,110 @@
             }
         }).then(function(response) {
             this.markFetchComplete();
-            return response.json().then(function(responseBody) {
-                var responseFlags = responseBody['flags'];
-                if (!responseFlags) {
-                    throw new Error('No flags in API response');
-                }
-                var flags = new Map();
-                var pendingFirstTimeEvents = {};
-
-                // Process flags from response
-                _.each(responseFlags, function(data, key) {
-                    // Check if this flag has any activated first-time events this session
-                    var hasActivatedEvent = false;
-                    var prefix = key + ':';
-                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                        if (eventKey.startsWith(prefix)) {
-                            hasActivatedEvent = true;
-                        }
-                    });
+            return response.json();
+        }.bind(this)).then(function(responseBody) {
+            var responseFlags = responseBody['flags'];
+            if (!responseFlags) {
+                throw new Error('No flags in API response');
+            }
+            var flags = new Map();
+            var pendingFirstTimeEvents = {};
+
+            // Process flags from response
+            _.each(responseFlags, function(data, key) {
+                // Check if this flag has any activated first-time events this session
+                var hasActivatedEvent = false;
+                var prefix = key + ':';
+                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                    if (eventKey.startsWith(prefix)) {
+                        hasActivatedEvent = true;
+                    }
+                });
 
-                    if (hasActivatedEvent) {
-                        // Preserve the activated variant, don't overwrite with server's current variant
-                        var currentFlag = this.flags && this.flags.get(key);
-                        if (currentFlag) {
-                            flags.set(key, currentFlag);
-                        }
-                    } else {
-                        // Use server's current variant
-                        flags.set(key, {
-                            'key': data['variant_key'],
-                            'value': data['variant_value'],
-                            'experiment_id': data['experiment_id'],
-                            'is_experiment_active': data['is_experiment_active'],
-                            'is_qa_tester': data['is_qa_tester']
-                        });
+                if (hasActivatedEvent) {
+                    // Preserve the activated variant, don't overwrite with server's current variant
+                    var currentFlag = this.flags && this.flags.get(key);
+                    if (currentFlag) {
+                        flags.set(key, currentFlag);
                     }
-                }, this);
+                } else {
+                    // Use server's current variant
+                    flags.set(key, {
+                        'key': data['variant_key'],
+                        'value': data['variant_value'],
+                        'experiment_id': data['experiment_id'],
+                        'is_experiment_active': data['is_experiment_active'],
+                        'is_qa_tester': data['is_qa_tester']
+                    });
+                }
+            }, this);
 
-                // Process top-level pending_first_time_events array
-                var topLevelDefinitions = responseBody['pending_first_time_events'];
-                if (topLevelDefinitions && topLevelDefinitions.length > 0) {
-                    _.each(topLevelDefinitions, function(def) {
-                        var flagKey = def['flag_key'];
-                        var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
+            // Process top-level pending_first_time_events array
+            var topLevelDefinitions = responseBody['pending_first_time_events'];
+            if (topLevelDefinitions && topLevelDefinitions.length > 0) {
+                _.each(topLevelDefinitions, function(def) {
+                    var flagKey = def['flag_key'];
+                    var eventKey = getPendingEventKey(flagKey, def['first_time_event_hash']);
 
-                        // Skip if this specific event has already been activated this session
-                        if (this.activatedFirstTimeEvents[eventKey]) {
-                            return;
-                        }
+                    // Skip if this specific event has already been activated this session
+                    if (this.activatedFirstTimeEvents[eventKey]) {
+                        return;
+                    }
 
-                        // Store pending event definition using composite key
-                        pendingFirstTimeEvents[eventKey] = {
-                            'flag_key': flagKey,
-                            'flag_id': def['flag_id'],
-                            'project_id': def['project_id'],
-                            'first_time_event_hash': def['first_time_event_hash'],
-                            'event_name': def['event_name'],
-                            'property_filters': def['property_filters'],
-                            'pending_variant': def['pending_variant']
-                        };
-                    }, this);
-                }
+                    // Store pending event definition using composite key
+                    pendingFirstTimeEvents[eventKey] = {
+                        'flag_key': flagKey,
+                        'flag_id': def['flag_id'],
+                        'project_id': def['project_id'],
+                        'first_time_event_hash': def['first_time_event_hash'],
+                        'event_name': def['event_name'],
+                        'property_filters': def['property_filters'],
+                        'pending_variant': def['pending_variant']
+                    };
+                }, this);
+            }
 
-                // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
-                if (this.activatedFirstTimeEvents) {
-                    _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
-                        var flagKey = getFlagKeyFromPendingEventKey(eventKey);
-                        if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
-                            // Keep the activated flag even though it's not in the new response
-                            flags.set(flagKey, this.flags.get(flagKey));
-                        }
-                    }, this);
-                }
+            // Preserve any activated orphaned flags (flags that were activated but are no longer in response)
+            if (this.activatedFirstTimeEvents) {
+                _.each(this.activatedFirstTimeEvents, function(activated, eventKey) {
+                    var flagKey = getFlagKeyFromPendingEventKey(eventKey);
+                    if (activated && !flags.has(flagKey) && this.flags && this.flags.has(flagKey)) {
+                        // Keep the activated flag even though it's not in the new response
+                        flags.set(flagKey, this.flags.get(flagKey));
+                    }
+                }, this);
+            }
 
-                this.flags = flags;
-                this.pendingFirstTimeEvents = pendingFirstTimeEvents;
-                this._traceparent = traceparent;
+            this.flags = flags;
+            this.pendingFirstTimeEvents = pendingFirstTimeEvents;
+            this._traceparent = traceparent;
 
-                this._loadTargetingIfNeeded();
-            }.bind(this)).catch(function(error) {
-                this.markFetchComplete();
-                logger$1.error(error);
-            }.bind(this));
+            this._loadTargetingIfNeeded();
         }.bind(this)).catch(function(error) {
-            this.markFetchComplete();
+            if (this._fetchInProgressStartTime) {
+                this.markFetchComplete();
+            }
             logger$1.error(error);
+            throw error;
         }.bind(this));
 
         return this.fetchPromise;
     };
 
+    FeatureFlagManager.prototype.loadFlags = function() {
+        if (!this.isSystemEnabled()) {
+            return Promise.resolve();
+        }
+        if (!this.trackedFeatures) {
+            logger$1.error('loadFlags called before init');
+            return Promise.resolve();
+        }
+        if (this._fetchInProgressStartTime) {
+            return this.fetchPromise;
+        }
+        return this.fetchFlags();
+    };
+
     FeatureFlagManager.prototype.markFetchComplete = function() {
         if (!this._fetchInProgressStartTime) {
             logger$1.error('Fetch in progress started time not set, cannot mark fetch complete');
@@ -26111,6 +26131,13 @@
         this.track('$experiment_started', trackingProperties);
     };
 
+    FeatureFlagManager.prototype.whenReady = function() {
+        if (this.fetchPromise) {
+            return this.fetchPromise;
+        }
+        return Promise.resolve();
+    };
+
     FeatureFlagManager.prototype.minApisSupported = function() {
         return !!this.fetch &&
           typeof Promise !== 'undefined' &&
@@ -26127,7 +26154,9 @@
     FeatureFlagManager.prototype['get_variant_value_sync'] = FeatureFlagManager.prototype.getVariantValueSync;
     FeatureFlagManager.prototype['is_enabled'] = FeatureFlagManager.prototype.isEnabled;
     FeatureFlagManager.prototype['is_enabled_sync'] = FeatureFlagManager.prototype.isEnabledSync;
+    FeatureFlagManager.prototype['load_flags'] = FeatureFlagManager.prototype.loadFlags;
     FeatureFlagManager.prototype['update_context'] = FeatureFlagManager.prototype.updateContext;
+    FeatureFlagManager.prototype['when_ready'] = FeatureFlagManager.prototype.whenReady;
 
     // Deprecated method
     FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
@@ -29483,7 +29512,9 @@
 
         // check feature flags again if distinct id has changed
         if (new_distinct_id !== previous_distinct_id) {
-            this.flags.fetchFlags();
+            this.flags.fetchFlags().catch(function() {
+                console$1.error('[flags] Error fetching flags during identify');
+            });
         }
     };
 

package/dist/mixpanel-with-recorder.min.d.ts

@@ -357,6 +357,7 @@ export interface FlagsUpdateContextOptions {
 
 export interface FlagsManager {
   are_flags_ready(): boolean;
+  load_flags(): Promise<void>;
   get_variant(
     featureName: string,
     fallback: FlagsVariant