posthog-js 1.29.3 → 1.31.0

package/dist/module.d.ts

@@ -188,6 +188,11 @@ interface PostHogConfig {
     _onCapture: (eventName: string, eventData: CaptureResult) => void;
     _capture_metrics: boolean;
     _capture_performance: boolean;
+    bootstrap: {
+        distinctID?: string;
+        isIdentifiedID?: boolean;
+        featureFlags?: Record<string, boolean | string>;
+    };
 }
 interface OptInOutCapturingOptions {
     capture: (event: string, properties: Properties, options: CaptureOptions) => void;
@@ -418,7 +423,7 @@ declare class PostHogFeatureFlags {
         send_event?: boolean;
     }): boolean;
     addFeatureFlagsHandler(handler: FeatureFlagsCallback): void;
-    receivedFeatureFlags(response: DecideResponse): void;
+    receivedFeatureFlags(response: Partial<DecideResponse>): void;
     override(flags: boolean | string[] | Record<string, string | boolean>): void;
     onFeatureFlags(callback: FeatureFlagsCallback): void;
 }
@@ -813,6 +818,7 @@ declare class SessionIdManager {
     _windowId: string | null | undefined;
     _sessionId: string | null | undefined;
     window_id_storage_key: string;
+    primary_window_exists_storage_key: string;
     _sessionStartTimestamp: number | null;
     _sessionActivityTimestamp: number | null;
     constructor(config: Partial<PostHogConfig>, persistence: PostHogPersistence);
@@ -821,6 +827,7 @@ declare class SessionIdManager {
     _setSessionId(sessionId: string | null, sessionActivityTimestamp: number | null, sessionStartTimestamp: number | null): void;
     _getSessionId(): [number, string, number];
     resetSessionId(): void;
+    _listenToReloadWindow(): void;
     checkAndGetSessionAndWindowId(readOnly?: boolean, _timestamp?: number | null): {
         sessionId: string;
         windowId: string;
@@ -925,6 +932,7 @@ declare class PostHog {
      * @param {Array} array
      */
     _execute_array(array: SnippetArrayItem[]): void;
+    _hasBootstrappedFeatureFlags(): boolean;
     /**
      * push() keeps the standard async-array-push
      * behavior around after the lib is loaded.

package/dist/module.js

@@ -885,7 +885,7 @@ var LZString = {
   }
 };
 
-var version = "1.29.3";
+var version = "1.31.0";
 
 // e.g.     Config.DEBUG = Config.DEBUG || instance.get_config('debug')
 
@@ -3294,6 +3294,7 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
   }, {
     key: "receivedFeatureFlags",
     value: function receivedFeatureFlags(response) {
+      this.instance.decideEndpointWasHit = true;
       parseFeatureFlagDecideResponse(response, this.instance.persistence);
       var flags = this.getFlags();
       var variants = this.getFlagVariants();
@@ -3971,8 +3972,9 @@ var Decide = /*#__PURE__*/function () {
   function Decide(instance) {
     _classCallCheck(this, Decide);
 
-    this.instance = instance;
-    this.instance.decideEndpointWasHit = false;
+    this.instance = instance; // don't need to wait for `decide` to return if flags were provided on initialisation
+
+    this.instance.decideEndpointWasHit = this.instance._hasBootstrappedFeatureFlags();
   }
 
   _createClass(Decide, [{
@@ -5547,12 +5549,28 @@ var SessionIdManager = /*#__PURE__*/function () {
     this._sessionId = undefined;
     this._sessionStartTimestamp = null;
     this._sessionActivityTimestamp = null;
+    var persistenceName = config['persistence_name'] || config['token'];
+    this.window_id_storage_key = 'ph_' + persistenceName + '_window_id';
+    this.primary_window_exists_storage_key = 'ph_' + persistenceName + '_primary_window_exists'; // primary_window_exists is set when the DOM has been loaded and is cleared on unload
+    // if it exists here it means there was no unload which suggests this window is opened as a tab duplication, window.open, etc.
+
+    if (!this.persistence.disabled && sessionStore.is_supported()) {
+      var lastWindowId = sessionStore.parse(this.window_id_storage_key);
+      var primaryWindowExists = sessionStore.parse(this.primary_window_exists_storage_key);
+
+      if (lastWindowId && !primaryWindowExists) {
+        // Persist window from previous storage state
+        this._windowId = lastWindowId;
+      } else {
+        // Wipe any reference to previous window id
+        sessionStore.remove(this.window_id_storage_key);
+      } // Flag this session as having a primary window
 
-    if (config['persistence_name']) {
-      this.window_id_storage_key = 'ph_' + config['persistence_name'] + '_window_id';
-    } else {
-      this.window_id_storage_key = 'ph_' + config['token'] + '_window_id';
+
+      sessionStore.set(this.primary_window_exists_storage_key, true);
     }
+
+    this._listenToReloadWindow();
   } // Note: this tries to store the windowId in sessionStorage. SessionStorage is unique to the current window/tab,
   // and persists page loads/reloads. So it's uniquely suited for storing the windowId. This function also respects
   // when persistence is disabled (by user config) and when sessionStorage is not supported (it *should* be supported on all browsers),
@@ -5579,7 +5597,8 @@ var SessionIdManager = /*#__PURE__*/function () {
 
       if (!this.persistence.disabled && sessionStore.is_supported()) {
         return sessionStore.parse(this.window_id_storage_key);
-      }
+      } // New window id will be generated
+
 
       return null;
     } // Note: 'this.persistence.register' can be disabled in the config.
@@ -5618,6 +5637,24 @@ var SessionIdManager = /*#__PURE__*/function () {
     value: function resetSessionId() {
       this._setSessionId(null, null, null);
     }
+    /*
+     * Listens to window unloads and removes the primaryWindowExists key from sessionStorage.
+     * Reloaded or fresh tabs created after a DOM unloads (reloading the same tab) WILL NOT have this primaryWindowExists flag in session storage.
+     * Cloned sessions (new tab, tab duplication, window.open(), ...) WILL have this primaryWindowExists flag in their copied session storage.
+     * We conditionally check the primaryWindowExists value in the constructor to decide if the window id in the last session storage should be carried over.
+     */
+
+  }, {
+    key: "_listenToReloadWindow",
+    value: function _listenToReloadWindow() {
+      var _this = this;
+
+      window.addEventListener('beforeunload', function () {
+        if (!_this.persistence.disabled && sessionStore.is_supported()) {
+          sessionStore.remove(_this.primary_window_exists_storage_key);
+        }
+      });
+    }
     /*
      * This function returns the current sessionId and windowId. It should be used to
      * access these values over directly calling `._sessionId` or `._windowId`. In addition
@@ -5828,6 +5865,8 @@ var SentryIntegration = /*#__PURE__*/_createClass(function SentryIntegration(_po
 
   this.setupOnce = function (addGlobalEventProcessor) {
     addGlobalEventProcessor(function (event) {
+      var _event$exception, _exceptions$, _exceptions$2;
+
       if (event.level !== 'error' || !_posthog.__loaded) return event;
       if (!event.tags) event.tags = {};
       event.tags['PostHog Person URL'] = _posthog.config.api_host + '/person/' + _posthog.get_distinct_id();
@@ -5836,9 +5875,13 @@ var SentryIntegration = /*#__PURE__*/_createClass(function SentryIntegration(_po
         event.tags['PostHog Recording URL'] = _posthog.config.api_host + '/recordings/#sessionRecordingId=' + _posthog.sessionManager.checkAndGetSessionAndWindowId(true).sessionId;
       }
 
+      var exceptions = ((_event$exception = event.exception) === null || _event$exception === void 0 ? void 0 : _event$exception.values) || [];
       var data = {
         $sentry_event_id: event.event_id,
-        $sentry_exception: event.exception
+        $sentry_exception: event.exception,
+        $sentry_exception_message: (_exceptions$ = exceptions[0]) === null || _exceptions$ === void 0 ? void 0 : _exceptions$.value,
+        $sentry_exception_type: (_exceptions$2 = exceptions[0]) === null || _exceptions$2 === void 0 ? void 0 : _exceptions$2.type,
+        $sentry_tags: event.tags
       };
       if (organization && projectId) data['$sentry_url'] = (prefix || 'https://sentry.io/organizations/') + organization + '/issues/?project=' + projectId + '&query=' + event.event_id;
 
@@ -5958,7 +6001,8 @@ var defaultConfig = function defaultConfig() {
     _capture_metrics: false,
     _capture_performance: false,
     name: 'posthog',
-    callback_fn: 'posthog._jsc'
+    callback_fn: 'posthog._jsc',
+    bootstrap: {}
   };
 };
 /**
@@ -6107,6 +6151,8 @@ var PostHog = /*#__PURE__*/function () {
   }, {
     key: "_init",
     value: function _init(token) {
+      var _config$bootstrap;
+
       var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var name = arguments.length > 2 ? arguments[2] : undefined;
       this.__loaded = true;
@@ -6131,14 +6177,43 @@ var PostHog = /*#__PURE__*/function () {
 
       this._gdpr_init();
 
+      if (((_config$bootstrap = config.bootstrap) === null || _config$bootstrap === void 0 ? void 0 : _config$bootstrap.distinctID) !== undefined) {
+        var _config$bootstrap2;
+
+        var uuid = this.get_config('get_device_id')(_UUID());
+        var deviceID = (_config$bootstrap2 = config.bootstrap) !== null && _config$bootstrap2 !== void 0 && _config$bootstrap2.isIdentifiedID ? uuid : config.bootstrap.distinctID;
+        this.register({
+          distinct_id: config.bootstrap.distinctID,
+          $device_id: deviceID
+        });
+      }
+
+      if (this._hasBootstrappedFeatureFlags()) {
+        var _config$bootstrap3;
+
+        var activeFlags = Object.keys(((_config$bootstrap3 = config.bootstrap) === null || _config$bootstrap3 === void 0 ? void 0 : _config$bootstrap3.featureFlags) || {}).filter(function (flag) {
+          var _config$bootstrap4, _config$bootstrap4$fe;
+
+          return !!((_config$bootstrap4 = config.bootstrap) !== null && _config$bootstrap4 !== void 0 && (_config$bootstrap4$fe = _config$bootstrap4.featureFlags) !== null && _config$bootstrap4$fe !== void 0 && _config$bootstrap4$fe[flag]);
+        }).reduce(function (res, key) {
+          var _config$bootstrap5, _config$bootstrap5$fe;
+
+          return res[key] = ((_config$bootstrap5 = config.bootstrap) === null || _config$bootstrap5 === void 0 ? void 0 : (_config$bootstrap5$fe = _config$bootstrap5.featureFlags) === null || _config$bootstrap5$fe === void 0 ? void 0 : _config$bootstrap5$fe[key]) || false, res;
+        }, {});
+        this.featureFlags.receivedFeatureFlags({
+          featureFlags: activeFlags
+        });
+      }
+
       if (!this.get_distinct_id()) {
         // There is no need to set the distinct id
         // or the device id if something was already stored
         // in the persitence
-        var uuid = this.get_config('get_device_id')(_UUID());
+        var _uuid = this.get_config('get_device_id')(_UUID());
+
         this.register_once({
-          distinct_id: uuid,
-          $device_id: uuid
+          distinct_id: _uuid,
+          $device_id: _uuid
         }, '');
       } // Set up event handler for pageleave
       // Use `onpagehide` if available, see https://calendar.perfplanet.com/2020/beaconing-in-practice/#beaconing-reliability-avoiding-abandons
@@ -6419,6 +6494,13 @@ var PostHog = /*#__PURE__*/function () {
       execute(other_calls, this);
       execute(capturing_calls, this);
     }
+  }, {
+    key: "_hasBootstrappedFeatureFlags",
+    value: function _hasBootstrappedFeatureFlags() {
+      var _this$config$bootstra, _this$config$bootstra2;
+
+      return ((_this$config$bootstra = this.config.bootstrap) === null || _this$config$bootstra === void 0 ? void 0 : _this$config$bootstra.featureFlags) && Object.keys((_this$config$bootstra2 = this.config.bootstrap) === null || _this$config$bootstra2 === void 0 ? void 0 : _this$config$bootstra2.featureFlags).length > 0 || false;
+    }
     /**
      * push() keeps the standard async-array-push
      * behavior around after the lib is loaded.