mixpanel-browser 2.77.0 → 2.78.0

package/dist/mixpanel.module.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

package/dist/mixpanel.module.js

@@ -25,7 +25,7 @@ if (typeof(window) === 'undefined') {
 
 var Config = {
     DEBUG: false,
-    LIB_VERSION: '2.77.0'
+    LIB_VERSION: '2.78.0'
 };
 
 // Window global names for async modules
@@ -26191,7 +26191,9 @@ FeatureFlagManager.prototype.init = function() {
     }
 
     this.flags = null;
-    this.fetchFlags();
+    this.fetchFlags().catch(function() {
+        logger$1.error('Error fetching flags during init');
+    });
 
     this.trackedFeatures = new Set();
     this.pendingFirstTimeEvents = {};
@@ -26232,8 +26234,12 @@ FeatureFlagManager.prototype.updateContext = function(newContext, options) {
     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() {
@@ -26270,96 +26276,110 @@ FeatureFlagManager.prototype.fetchFlags = function() {
         }
     }).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');
@@ -26639,6 +26659,13 @@ FeatureFlagManager.prototype.trackFeatureCheck = function(featureName, feature)
     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' &&
@@ -26655,7 +26682,9 @@ FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype
 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;
@@ -30011,7 +30040,9 @@ MixpanelLib.prototype.identify = function(
 
     // 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.umd.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

package/dist/mixpanel.umd.js

@@ -31,7 +31,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.77.0'
+        LIB_VERSION: '2.78.0'
     };
 
     // Window global names for async modules
@@ -26197,7 +26197,9 @@
         }
 
         this.flags = null;
-        this.fetchFlags();
+        this.fetchFlags().catch(function() {
+            logger$1.error('Error fetching flags during init');
+        });
 
         this.trackedFeatures = new Set();
         this.pendingFirstTimeEvents = {};
@@ -26238,8 +26240,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() {
@@ -26276,96 +26282,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');
@@ -26645,6 +26665,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' &&
@@ -26661,7 +26688,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;
@@ -30017,7 +30046,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixpanel-browser",
-  "version": "2.77.0",
+  "version": "2.78.0",
   "description": "The official Mixpanel JavaScript browser client library",
   "main": "dist/mixpanel.cjs.js",
   "module": "dist/mixpanel.module.js",

package/src/config.js

@@ -1,6 +1,6 @@
 export var Config = {
     DEBUG: false,
-    LIB_VERSION: '2.77.0'
+    LIB_VERSION: '2.78.0'
 };
 
 // Window global names for async modules

package/src/flags/CLAUDE.md

@@ -0,0 +1,24 @@
+# Flags Module
+
+## Testing
+- Test runner is **mocha** (not jest): `BABEL_ENV=test npx mocha --require babel-core/register tests/unit/flags.js`
+- Unit tests live in `tests/unit/flags.js`
+
+## Code style
+- ES5 prototypal classes — no arrow functions, no ES6 classes
+- Use `.bind(this)` for `this` context in promise `.then()` / `.catch()` callbacks
+- Flat promise chains preferred over nested `.then()` inside `.then()`
+
+## Public API pattern
+- Snake-case aliases are registered at the bottom of `index.js` (e.g., `prototype['load_flags'] = prototype.loadFlags`)
+- New public methods need both the camelCase implementation and a snake_case alias
+
+## Error handling convention
+- `fetchFlags()` always rejects on error (single `.catch` that logs and re-throws)
+- Fire-and-forget callers (`init`, `updateContext`, `mixpanel-core.js` identify call) swallow errors at the call site with `.catch(function() {})`
+- User-facing methods like `loadFlags` propagate rejections so the caller can handle them
+
+## Key files
+- `src/flags/index.js` — `FeatureFlagManager` class (fetch, load, variants, first-time events)
+- `src/mixpanel-core.js` — calls `fetchFlags()` on distinct_id change (~line 1764)
+- `tests/unit/flags.js` — all flag unit tests