mixpanel-browser 2.64.0 → 2.66.0

package/dist/mixpanel-with-recorder.js

@@ -13945,7 +13945,7 @@
 
     var Config = {
         DEBUG: false,
-        LIB_VERSION: '2.64.0'
+        LIB_VERSION: '2.66.0'
     };
 
     /* eslint camelcase: "off", eqeqeq: "off" */
@@ -15430,6 +15430,9 @@
                 return 'Microsoft Edge';
             } else if (_.includes(user_agent, 'FBIOS')) {
                 return 'Facebook Mobile';
+            } else if (_.includes(user_agent, 'Whale/')) {
+                // https://user-agents.net/browsers/whale-browser
+                return 'Whale Browser';
             } else if (_.includes(user_agent, 'Chrome')) {
                 return 'Chrome';
             } else if (_.includes(user_agent, 'CriOS')) {
@@ -15481,7 +15484,8 @@
                 'Android Mobile': /android\s(\d+(\.\d+)?)/,
                 'Samsung Internet': /SamsungBrowser\/(\d+(\.\d+)?)/,
                 'Internet Explorer': /(rv:|MSIE )(\d+(\.\d+)?)/,
-                'Mozilla': /rv:(\d+(\.\d+)?)/
+                'Mozilla': /rv:(\d+(\.\d+)?)/,
+                'Whale Browser': /Whale\/(\d+(\.\d+)?)/
             };
             var regex = versionRegexs[browser];
             if (regex === undefined) {
@@ -17348,8 +17352,8 @@
                 retryAfter: response.headers.get('Retry-After')
             });
         }.bind(this);
-
-        win['fetch'](this.getConfig('api_host') + '/' + this.getConfig('api_routes')['record'] + '?' + new URLSearchParams(reqParams), {
+        var apiHost = (this._mixpanel.get_api_host && this._mixpanel.get_api_host('record')) || this.getConfig('api_host');
+        win['fetch'](apiHost + '/' + this.getConfig('api_routes')['record'] + '?' + new URLSearchParams(reqParams), {
             'method': 'POST',
             'headers': {
                 'Authorization': 'Basic ' + btoa(this.getConfig('token') + ':'),
@@ -17566,6 +17570,7 @@
         this._flushInactivePromise = this.recordingRegistry.flushInactiveRecordings();
 
         this.activeRecording = null;
+        this.stopRecordingInProgress = false;
     };
 
     MixpanelRecorder.prototype.startRecording = function(options) {
@@ -17614,19 +17619,26 @@
     };
 
     MixpanelRecorder.prototype.stopRecording = function() {
-        var stopPromise = this._stopCurrentRecording(false);
-        this.recordingRegistry.clearActiveRecording();
-        this.activeRecording = null;
-        return stopPromise;
+        // Prevents activeSerializedRecording from being reused when stopping the recording.
+        this.stopRecordingInProgress = true;
+        return this._stopCurrentRecording(false, true).then(function() {
+            return this.recordingRegistry.clearActiveRecording();
+        }.bind(this)).then(function() {
+            this.stopRecordingInProgress = false;
+        }.bind(this));
     };
 
     MixpanelRecorder.prototype.pauseRecording = function() {
         return this._stopCurrentRecording(false);
     };
 
-    MixpanelRecorder.prototype._stopCurrentRecording = function(skipFlush) {
+    MixpanelRecorder.prototype._stopCurrentRecording = function(skipFlush, disableActiveRecording) {
         if (this.activeRecording) {
-            return this.activeRecording.stopRecording(skipFlush);
+            var stopRecordingPromise = this.activeRecording.stopRecording(skipFlush);
+            if (disableActiveRecording) {
+                this.activeRecording = null;
+            }
+            return stopRecordingPromise;
         }
         return PromisePolyfill.resolve();
     };
@@ -17639,7 +17651,7 @@
 
         return this.recordingRegistry.getActiveRecording()
             .then(function (activeSerializedRecording) {
-                if (activeSerializedRecording) {
+                if (activeSerializedRecording && !this.stopRecordingInProgress) {
                     return this.startRecording({activeSerializedRecording: activeSerializedRecording});
                 } else if (startNewIfInactive) {
                     return this.startRecording({shouldStopBatcher: false});
@@ -17843,7 +17855,9 @@
                     '$elements':  elementsJson,
                     '$el_attr__href': href,
                     '$viewportHeight': Math.max(docElement['clientHeight'], win['innerHeight'] || 0),
-                    '$viewportWidth': Math.max(docElement['clientWidth'], win['innerWidth'] || 0)
+                    '$viewportWidth': Math.max(docElement['clientWidth'], win['innerWidth'] || 0),
+                    '$pageHeight': document$1['body']['offsetHeight'] || 0,
+                    '$pageWidth': document$1['body']['offsetWidth'] || 0,
                 };
                 _.each(captureExtraAttrs, function(attr) {
                     if (!blockAttrsSet[attr] && target.hasAttribute(attr)) {
@@ -18574,19 +18588,19 @@
         return this.getFullConfig()[key];
     };
 
-    FeatureFlagManager.prototype.isEnabled = function() {
+    FeatureFlagManager.prototype.isSystemEnabled = function() {
         return !!this.getMpConfig(FLAGS_CONFIG_KEY);
     };
 
-    FeatureFlagManager.prototype.areFeaturesReady = function() {
-        if (!this.isEnabled()) {
+    FeatureFlagManager.prototype.areFlagsReady = function() {
+        if (!this.isSystemEnabled()) {
             logger.error('Feature Flags not enabled');
         }
         return !!this.flags;
     };
 
     FeatureFlagManager.prototype.fetchFlags = function() {
-        if (!this.isEnabled()) {
+        if (!this.isSystemEnabled()) {
             return;
         }
 
@@ -18612,7 +18626,7 @@
                 _.each(responseFlags, function(data, key) {
                     flags.set(key, {
                         'key': data['variant_key'],
-                        'data': data['variant_value']
+                        'value': data['variant_value']
                     });
                 });
                 this.flags = flags;
@@ -18622,7 +18636,7 @@
         }.bind(this)).catch(function() {});
     };
 
-    FeatureFlagManager.prototype.getFeature = function(featureName, fallback) {
+    FeatureFlagManager.prototype.getVariant = function(featureName, fallback) {
         if (!this.fetchPromise) {
             return new Promise(function(resolve) {
                 logger.critical('Feature Flags not initialized');
@@ -18631,15 +18645,15 @@
         }
 
         return this.fetchPromise.then(function() {
-            return this.getFeatureSync(featureName, fallback);
+            return this.getVariantSync(featureName, fallback);
         }.bind(this)).catch(function(error) {
             logger.error(error);
             return fallback;
         });
     };
 
-    FeatureFlagManager.prototype.getFeatureSync = function(featureName, fallback) {
-        if (!this.areFeaturesReady()) {
+    FeatureFlagManager.prototype.getVariantSync = function(featureName, fallback) {
+        if (!this.areFlagsReady()) {
             logger.log('Flags not loaded yet');
             return fallback;
         }
@@ -18652,31 +18666,37 @@
         return feature;
     };
 
-    FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
-        return this.getFeature(featureName, {'data': fallbackValue}).then(function(feature) {
-            return feature['data'];
+    FeatureFlagManager.prototype.getVariantValue = function(featureName, fallbackValue) {
+        return this.getVariant(featureName, {'value': fallbackValue}).then(function(feature) {
+            return feature['value'];
         }).catch(function(error) {
             logger.error(error);
             return fallbackValue;
         });
     };
 
-    FeatureFlagManager.prototype.getFeatureDataSync = function(featureName, fallbackValue) {
-        return this.getFeatureSync(featureName, {'data': fallbackValue})['data'];
+    // TODO remove deprecated method
+    FeatureFlagManager.prototype.getFeatureData = function(featureName, fallbackValue) {
+        logger.critical('mixpanel.flags.get_feature_data() is deprecated and will be removed in a future release. Use mixpanel.flags.get_variant_value() instead.');
+        return this.getVariantValue(featureName, fallbackValue);
+    };
+
+    FeatureFlagManager.prototype.getVariantValueSync = function(featureName, fallbackValue) {
+        return this.getVariantSync(featureName, {'value': fallbackValue})['value'];
     };
 
-    FeatureFlagManager.prototype.isFeatureEnabled = function(featureName, fallbackValue) {
-        return this.getFeatureData(featureName).then(function() {
-            return this.isFeatureEnabledSync(featureName, fallbackValue);
+    FeatureFlagManager.prototype.isEnabled = function(featureName, fallbackValue) {
+        return this.getVariantValue(featureName).then(function() {
+            return this.isEnabledSync(featureName, fallbackValue);
         }.bind(this)).catch(function(error) {
             logger.error(error);
             return fallbackValue;
         });
     };
 
-    FeatureFlagManager.prototype.isFeatureEnabledSync = function(featureName, fallbackValue) {
+    FeatureFlagManager.prototype.isEnabledSync = function(featureName, fallbackValue) {
         fallbackValue = fallbackValue || false;
-        var val = this.getFeatureDataSync(featureName, fallbackValue);
+        var val = this.getVariantValueSync(featureName, fallbackValue);
         if (val !== true && val !== false) {
             logger.error('Feature flag "' + featureName + '" value: ' + val + ' is not a boolean; returning fallback value: ' + fallbackValue);
             val = fallbackValue;
@@ -18705,13 +18725,16 @@
 
     safewrapClass(FeatureFlagManager);
 
-    FeatureFlagManager.prototype['are_features_ready'] = FeatureFlagManager.prototype.areFeaturesReady;
-    FeatureFlagManager.prototype['get_feature'] = FeatureFlagManager.prototype.getFeature;
+    FeatureFlagManager.prototype['are_flags_ready'] = FeatureFlagManager.prototype.areFlagsReady;
+    FeatureFlagManager.prototype['get_variant'] = FeatureFlagManager.prototype.getVariant;
+    FeatureFlagManager.prototype['get_variant_sync'] = FeatureFlagManager.prototype.getVariantSync;
+    FeatureFlagManager.prototype['get_variant_value'] = FeatureFlagManager.prototype.getVariantValue;
+    FeatureFlagManager.prototype['get_variant_value_sync'] = FeatureFlagManager.prototype.getVariantValueSync;
+    FeatureFlagManager.prototype['is_enabled'] = FeatureFlagManager.prototype.isEnabled;
+    FeatureFlagManager.prototype['is_enabled_sync'] = FeatureFlagManager.prototype.isEnabledSync;
+
+    // Deprecated method
     FeatureFlagManager.prototype['get_feature_data'] = FeatureFlagManager.prototype.getFeatureData;
-    FeatureFlagManager.prototype['get_feature_data_sync'] = FeatureFlagManager.prototype.getFeatureDataSync;
-    FeatureFlagManager.prototype['get_feature_sync'] = FeatureFlagManager.prototype.getFeatureSync;
-    FeatureFlagManager.prototype['is_feature_enabled'] = FeatureFlagManager.prototype.isFeatureEnabled;
-    FeatureFlagManager.prototype['is_feature_enabled_sync'] = FeatureFlagManager.prototype.isFeatureEnabledSync;
 
     /* eslint camelcase: "off" */
 
@@ -19130,7 +19153,7 @@
         return this._mixpanel._track_or_batch({
             type: 'groups',
             data: date_encoded_data,
-            endpoint: this._get_config('api_host') + '/' +  this._get_config('api_routes')['groups'],
+            endpoint: this._mixpanel.get_api_host('groups') + '/' +  this._get_config('api_routes')['groups'],
             batcher: this._mixpanel.request_batchers.groups
         }, callback);
     };
@@ -19407,18 +19430,8 @@
      * @param {Function} [callback] If provided, the callback will be called when the server responds
      * @deprecated
      */
-    MixpanelPeople.prototype.track_charge = addOptOutCheckMixpanelPeople(function(amount, properties, callback) {
-        if (!_.isNumber(amount)) {
-            amount = parseFloat(amount);
-            if (isNaN(amount)) {
-                console$1.error('Invalid value passed to mixpanel.people.track_charge - must be a number');
-                return;
-            }
-        }
-
-        return this.append('$transactions', _.extend({
-            '$amount': amount
-        }, properties), callback);
+    MixpanelPeople.prototype.track_charge = addOptOutCheckMixpanelPeople(function() {
+        console$1.error('mixpanel.people.track_charge() is deprecated and no longer has any effect.');
     });
 
     /*
@@ -19492,7 +19505,7 @@
         return this._mixpanel._track_or_batch({
             type: 'people',
             data: date_encoded_data,
-            endpoint: this._get_config('api_host') + '/' +  this._get_config('api_routes')['engage'],
+            endpoint: this._mixpanel.get_api_host('people') + '/' +  this._get_config('api_routes')['engage'],
             batcher: this._mixpanel.request_batchers.people
         }, callback);
     };
@@ -20129,7 +20142,9 @@
      */
     var DEFAULT_CONFIG = {
         'api_host':                          'https://api-js.mixpanel.com',
+        'api_hosts':                         {},
         'api_routes':                        DEFAULT_API_ROUTES,
+        'api_extra_query_params':            {},
         'api_method':                        'POST',
         'api_transport':                     'XHR',
         'api_payload_format':                PAYLOAD_TYPE_BASE64,
@@ -20513,20 +20528,23 @@
 
     MixpanelLib.prototype.stop_session_recording = function () {
         if (this._recorder) {
-            this._recorder['stopRecording']();
+            return this._recorder['stopRecording']();
         }
+        return Promise.resolve();
     };
 
     MixpanelLib.prototype.pause_session_recording = function () {
         if (this._recorder) {
-            this._recorder['pauseRecording']();
+            return this._recorder['pauseRecording']();
         }
+        return Promise.resolve();
     };
 
     MixpanelLib.prototype.resume_session_recording = function () {
         if (this._recorder) {
-            this._recorder['resumeRecording']();
+            return this._recorder['resumeRecording']();
         }
+        return Promise.resolve();
     };
 
     MixpanelLib.prototype.is_recording_heatmap_data = function () {
@@ -20717,6 +20735,8 @@
             delete data['data'];
         }
 
+        _.extend(data, this.get_config('api_extra_query_params'));
+
         url += '?' + _.HTTPBuildQuery(data);
 
         var lib = this;
@@ -21124,7 +21144,7 @@
         var ret = this._track_or_batch({
             type: 'events',
             data: data,
-            endpoint: this.get_config('api_host') + '/' + this.get_config('api_routes')['track'],
+            endpoint: this.get_api_host('events') + '/' + this.get_config('api_routes')['track'],
             batcher: this.request_batchers.events,
             should_send_immediately: should_send_immediately,
             send_request_options: options
@@ -21626,13 +21646,31 @@
      * Useful for clearing data when a user logs out.
      */
     MixpanelLib.prototype.reset = function() {
-        this['persistence'].clear();
-        this._flags.identify_called = false;
-        var uuid = _.UUID();
-        this.register_once({
-            'distinct_id': DEVICE_ID_PREFIX + uuid,
-            '$device_id': uuid
-        }, '');
+        var self = this;
+
+        var reset = function () {
+            self['persistence'].clear();
+            self._flags.identify_called = false;
+            var uuid = _.UUID();
+            self.register_once({
+                'distinct_id': DEVICE_ID_PREFIX + uuid,
+                '$device_id': uuid
+            }, '');
+        };
+
+        if (self._recorder) {
+            self.stop_session_recording()
+                .then(function () {
+                    reset();
+                    self._check_and_start_session_recording();
+                })
+                .catch(_.bind(function (err) {
+                    reset();
+                    this.report_error('Error restarting recording session', err);
+                }, this));
+        } else {
+            reset();
+        }
     };
 
     /**
@@ -21943,6 +21981,16 @@
         return this['persistence'].load_prop([property_name]);
     };
 
+    /**
+     * Get the API host for a specific endpoint type, falling back to the default api_host if not specified
+     *
+     * @param {String} endpoint_type The type of endpoint (e.g., "events", "people", "groups")
+     * @returns {String} The API host to use for this endpoint
+     */
+    MixpanelLib.prototype.get_api_host = function(endpoint_type) {
+        return this.get_config('api_hosts')[endpoint_type] || this.get_config('api_host');
+    };
+
     MixpanelLib.prototype.toString = function() {
         var name = this.get_config('name');
         if (name !== PRIMARY_INSTANCE_NAME) {
@@ -22238,6 +22286,7 @@
     MixpanelLib.prototype['name_tag']                           = MixpanelLib.prototype.name_tag;
     MixpanelLib.prototype['set_config']                         = MixpanelLib.prototype.set_config;
     MixpanelLib.prototype['get_config']                         = MixpanelLib.prototype.get_config;
+    MixpanelLib.prototype['get_api_host']                       = MixpanelLib.prototype.get_api_host;
     MixpanelLib.prototype['get_property']                       = MixpanelLib.prototype.get_property;
     MixpanelLib.prototype['get_distinct_id']                    = MixpanelLib.prototype.get_distinct_id;
     MixpanelLib.prototype['toString']                           = MixpanelLib.prototype.toString;