posthog-js 1.40.2 → 1.41.0

package/dist/module.d.ts

@@ -223,6 +223,7 @@ interface PostHogConfig {
         distinctID?: string;
         isIdentifiedID?: boolean;
         featureFlags?: Record<string, boolean | string>;
+        featureFlagPayloads?: Record<string, JsonType>;
     };
     segment?: any;
 }
@@ -293,6 +294,7 @@ interface XHRParams extends QueuedRequestData {
     captureMetrics: CaptureMetrics;
     retryQueue: RetryQueue;
     onXHRError: (req: XMLHttpRequest) => void;
+    timeout?: number;
 }
 interface DecideResponse {
     status: number;
@@ -302,6 +304,8 @@ interface DecideResponse {
     };
     custom_properties: AutoCaptureCustomProperty[];
     featureFlags: Record<string, string | boolean>;
+    featureFlagPayloads: Record<string, JsonType>;
+    errorsWhileComputingFlags: boolean;
     capturePerformance?: boolean;
     sessionRecording?: {
         endpoint?: string;
@@ -377,6 +381,9 @@ interface JSC {
     [key: string]: (response: any) => void;
 }
 declare type SnippetArrayItem = [method: string, ...args: any[]];
+declare type JsonType = string | number | boolean | null | {
+    [key: string]: JsonType;
+} | Array<JsonType>;
 
 /**
  * PostHog People Object
@@ -458,6 +465,7 @@ declare class PostHogFeatureFlags {
     constructor(instance: PostHog);
     getFlags(): string[];
     getFlagVariants(): Record<string, string | boolean>;
+    getFlagPayloads(): Record<string, JsonType>;
     /**
      * Reloads feature flags asynchronously.
      *
@@ -476,6 +484,7 @@ declare class PostHogFeatureFlags {
     getFeatureFlag(key: string, options?: {
         send_event?: boolean;
     }): boolean | string;
+    getFeatureFlagPayload(key: string): JsonType;
     isFeatureEnabled(key: string, options?: {
         send_event?: boolean;
     }): boolean;
@@ -1108,6 +1117,7 @@ declare class PostHog {
     getFeatureFlag(key: string, options?: {
         send_event?: boolean;
     }): boolean | string | undefined;
+    getFeatureFlagPayload(key: string): JsonType;
     isFeatureEnabled(key: string, options?: isFeatureEnabledOptions): boolean;
     reloadFeatureFlags(): void;
     onFeatureFlags(callback: (flags: string[], variants: Record<string, boolean | string>) => void): void;
@@ -1505,4 +1515,4 @@ declare class PostHog {
 
 declare const posthog: PostHog;
 
-export { AutoCaptureCustomProperty, AutocaptureCompatibleElement, AutocaptureConfig, Breaker, CaptureCallback, CaptureOptions, CaptureResult, Compression, CompressionData, DecideResponse, DomAutocaptureEvents, EventHandler, FeatureFlagsCallback, GDPROptions, JSC, OptInOutCapturingOptions, PersistentStore, PostData, PostHog, PostHogConfig, Properties, Property, QueuedRequestData, RequestCallback, RetryQueueElement, SessionRecordingOptions, SnippetArrayItem, ToolbarParams, ToolbarSource, ToolbarUserIntent, ToolbarVersion, XHROptions, XHRParams, posthog as default, isFeatureEnabledOptions, posthog };
+export { AutoCaptureCustomProperty, AutocaptureCompatibleElement, AutocaptureConfig, Breaker, CaptureCallback, CaptureOptions, CaptureResult, Compression, CompressionData, DecideResponse, DomAutocaptureEvents, EventHandler, FeatureFlagsCallback, GDPROptions, JSC, JsonType, OptInOutCapturingOptions, PersistentStore, PostData, PostHog, PostHogConfig, Properties, Property, QueuedRequestData, RequestCallback, RetryQueueElement, SessionRecordingOptions, SnippetArrayItem, ToolbarParams, ToolbarSource, ToolbarUserIntent, ToolbarVersion, XHROptions, XHRParams, posthog as default, isFeatureEnabledOptions, posthog };

package/dist/module.js

@@ -921,7 +921,7 @@ var LZString = {
   }
 };
 
-var version = "1.40.2";
+var version = "1.41.0";
 
 // e.g.     Config.DEBUG = Config.DEBUG || instance.get_config('debug')
 
@@ -3172,12 +3172,21 @@ var PostHogPeople = /*#__PURE__*/function () {
   return PostHogPeople;
 }();
 
+var PERSISTENCE_ACTIVE_FEATURE_FLAGS = '$active_feature_flags';
+var PERSISTENCE_ENABLED_FEATURE_FLAGS = '$enabled_feature_flags';
+var PERSISTENCE_OVERRIDE_FEATURE_FLAGS = '$override_feature_flags';
+var PERSISTENCE_FEATURE_FLAG_PAYLOADS = '$feature_flag_payloads';
 var parseFeatureFlagDecideResponse = function parseFeatureFlagDecideResponse(response, persistence) {
+  var currentFlags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var currentFlagPayloads = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
   var flags = response['featureFlags'];
+  var flagPayloads = response['featureFlagPayloads'];
 
   if (flags) {
     // using the v1 api
     if (Array.isArray(flags)) {
+      var _persistence$register;
+
       var $enabled_feature_flags = {};
 
       if (flags) {
@@ -3186,21 +3195,27 @@ var parseFeatureFlagDecideResponse = function parseFeatureFlagDecideResponse(res
         }
       }
 
-      persistence && persistence.register({
-        $active_feature_flags: flags,
-        $enabled_feature_flags: $enabled_feature_flags
-      });
+      persistence && persistence.register((_persistence$register = {}, _defineProperty(_persistence$register, PERSISTENCE_ACTIVE_FEATURE_FLAGS, flags), _defineProperty(_persistence$register, PERSISTENCE_ENABLED_FEATURE_FLAGS, $enabled_feature_flags), _persistence$register));
     } else {
-      // using the v2 api
-      persistence && persistence.register({
-        $active_feature_flags: Object.keys(flags || {}),
-        $enabled_feature_flags: flags || {}
-      });
+      var _persistence$register2;
+
+      // using the v2+ api
+      var newFeatureFlags = flags;
+      var newFeatureFlagPayloads = flagPayloads;
+
+      if (response.errorsWhileComputingFlags) {
+        // if not all flags were computed, we upsert flags instead of replacing them
+        newFeatureFlags = _objectSpread2(_objectSpread2({}, currentFlags), newFeatureFlags);
+        newFeatureFlagPayloads = _objectSpread2(_objectSpread2({}, currentFlagPayloads), newFeatureFlagPayloads);
+      }
+
+      persistence && persistence.register((_persistence$register2 = {}, _defineProperty(_persistence$register2, PERSISTENCE_ACTIVE_FEATURE_FLAGS, Object.keys(newFeatureFlags || {})), _defineProperty(_persistence$register2, PERSISTENCE_ENABLED_FEATURE_FLAGS, newFeatureFlags || {}), _defineProperty(_persistence$register2, PERSISTENCE_FEATURE_FLAG_PAYLOADS, newFeatureFlagPayloads || {}), _persistence$register2));
     }
   } else {
     if (persistence) {
-      persistence.unregister('$active_feature_flags');
-      persistence.unregister('$enabled_feature_flags');
+      persistence.unregister(PERSISTENCE_ACTIVE_FEATURE_FLAGS);
+      persistence.unregister(PERSISTENCE_ENABLED_FEATURE_FLAGS);
+      persistence.unregister(PERSISTENCE_FEATURE_FLAG_PAYLOADS);
     }
   }
 };
@@ -3224,8 +3239,8 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
   }, {
     key: "getFlagVariants",
     value: function getFlagVariants() {
-      var enabledFlags = this.instance.get_property('$enabled_feature_flags');
-      var overriddenFlags = this.instance.get_property('$override_feature_flags');
+      var enabledFlags = this.instance.get_property(PERSISTENCE_ENABLED_FEATURE_FLAGS);
+      var overriddenFlags = this.instance.get_property(PERSISTENCE_OVERRIDE_FEATURE_FLAGS);
 
       if (!overriddenFlags) {
         return enabledFlags || {};
@@ -3254,6 +3269,12 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
 
       return finalFlags;
     }
+  }, {
+    key: "getFlagPayloads",
+    value: function getFlagPayloads() {
+      var flagPayloads = this.instance.get_property(PERSISTENCE_FEATURE_FLAG_PAYLOADS);
+      return flagPayloads || {};
+    }
     /**
      * Reloads feature flags asynchronously.
      *
@@ -3319,7 +3340,7 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
 
       var encoded_data = _base64Encode(json_data);
 
-      this.instance._send_request(this.instance.get_config('api_host') + '/decide/?v=2', {
+      this.instance._send_request(this.instance.get_config('api_host') + '/decide/?v=3', {
         data: encoded_data
       }, {
         method: 'POST'
@@ -3328,7 +3349,9 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
         // makes it through
         _this2.$anon_distinct_id = undefined;
 
-        _this2.receivedFeatureFlags(response); // :TRICKY: Reload - start another request if queued!
+        if (response && response.status === 200) {
+          _this2.receivedFeatureFlags(response);
+        } // :TRICKY: Reload - start another request if queued!
 
 
         _this2.setReloadingPaused(false);
@@ -3369,6 +3392,12 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
 
       return flagValue;
     }
+  }, {
+    key: "getFeatureFlagPayload",
+    value: function getFeatureFlagPayload(key) {
+      var payloads = this.getFlagPayloads();
+      return payloads[key];
+    }
     /*
      * See if feature flag is enabled for user.
      *
@@ -3401,7 +3430,9 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
     key: "receivedFeatureFlags",
     value: function receivedFeatureFlags(response) {
       this.instance.decideEndpointWasHit = true;
-      parseFeatureFlagDecideResponse(response, this.instance.persistence);
+      var currentFlags = this.getFlagVariants();
+      var currentFlagPayloads = this.getFlagPayloads();
+      parseFeatureFlagDecideResponse(response, this.instance.persistence, currentFlags, currentFlagPayloads);
       var flags = this.getFlags();
       var variants = this.getFlagVariants();
       this.featureFlagEventHandlers.forEach(function (handler) {
@@ -3426,7 +3457,7 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
       this._override_warning = false;
 
       if (flags === false) {
-        this.instance.persistence.unregister('$override_feature_flags');
+        this.instance.persistence.unregister(PERSISTENCE_OVERRIDE_FEATURE_FLAGS);
       } else if (Array.isArray(flags)) {
         var flagsObj = {};
 
@@ -3434,13 +3465,9 @@ var PostHogFeatureFlags = /*#__PURE__*/function () {
           flagsObj[flags[i]] = true;
         }
 
-        this.instance.persistence.register({
-          $override_feature_flags: flagsObj
-        });
+        this.instance.persistence.register(_defineProperty({}, PERSISTENCE_OVERRIDE_FEATURE_FLAGS, flagsObj));
       } else {
-        this.instance.persistence.register({
-          $override_feature_flags: flags
-        });
+        this.instance.persistence.register(_defineProperty({}, PERSISTENCE_OVERRIDE_FEATURE_FLAGS, flags));
       }
     }
     /*
@@ -4344,7 +4371,7 @@ var Decide = /*#__PURE__*/function () {
 
       var encoded_data = _base64Encode(json_data);
 
-      this.instance._send_request("".concat(this.instance.get_config('api_host'), "/decide/?v=2"), {
+      this.instance._send_request("".concat(this.instance.get_config('api_host'), "/decide/?v=3"), {
         data: encoded_data,
         verbose: true
       }, {
@@ -4379,7 +4406,11 @@ var Decide = /*#__PURE__*/function () {
       (_this$instance$sessio = this.instance.sessionRecording) === null || _this$instance$sessio === void 0 ? void 0 : _this$instance$sessio.afterDecideResponse(response);
       autocapture.afterDecideResponse(response, this.instance);
       (_this$instance$webPer = this.instance.webPerformance) === null || _this$instance$webPer === void 0 ? void 0 : _this$instance$webPer.afterDecideResponse(response);
-      this.instance.featureFlags.receivedFeatureFlags(response);
+
+      if (response && response.status === 200) {
+        this.instance.featureFlags.receivedFeatureFlags(response);
+      }
+
       this.instance['compression'] = {};
 
       if (response['supportedCompression'] && !this.instance.get_config('disable_compression')) {
@@ -5728,7 +5759,9 @@ var xhr = function xhr(_ref) {
       callback = _ref.callback,
       retriesPerformedSoFar = _ref.retriesPerformedSoFar,
       retryQueue = _ref.retryQueue,
-      onXHRError = _ref.onXHRError;
+      onXHRError = _ref.onXHRError,
+      _ref$timeout = _ref.timeout,
+      timeout = _ref$timeout === void 0 ? 10000 : _ref$timeout;
   var req = new XMLHttpRequest();
   req.open(options.method || 'GET', url, true);
   var body = encodePostData(data, options);
@@ -5741,9 +5774,10 @@ var xhr = function xhr(_ref) {
 
   if (options.method === 'POST' && !options.blob) {
     req.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
-  } // send the ph_optout cookie
-  // withCredentials cannot be modified until after calling .open on Android and Mobile Safari
+  }
 
+  req.timeout = timeout; // send the ph_optout cookie
+  // withCredentials cannot be modified until after calling .open on Android and Mobile Safari
 
   req.withCredentials = true;
 
@@ -6625,7 +6659,7 @@ var PostHog = /*#__PURE__*/function () {
       }
 
       if (this._hasBootstrappedFeatureFlags()) {
-        var _config$bootstrap3;
+        var _config$bootstrap3, _config$bootstrap6;
 
         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;
@@ -6636,8 +6670,22 @@ var PostHog = /*#__PURE__*/function () {
 
           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;
         }, {});
+        var featureFlagPayloads = Object.keys(((_config$bootstrap6 = config.bootstrap) === null || _config$bootstrap6 === void 0 ? void 0 : _config$bootstrap6.featureFlagPayloads) || {}).filter(function (key) {
+          return activeFlags[key];
+        }).reduce(function (res, key) {
+          var _config$bootstrap7, _config$bootstrap7$fe;
+
+          if ((_config$bootstrap7 = config.bootstrap) !== null && _config$bootstrap7 !== void 0 && (_config$bootstrap7$fe = _config$bootstrap7.featureFlagPayloads) !== null && _config$bootstrap7$fe !== void 0 && _config$bootstrap7$fe[key]) {
+            var _config$bootstrap8, _config$bootstrap8$fe;
+
+            res[key] = (_config$bootstrap8 = config.bootstrap) === null || _config$bootstrap8 === void 0 ? void 0 : (_config$bootstrap8$fe = _config$bootstrap8.featureFlagPayloads) === null || _config$bootstrap8$fe === void 0 ? void 0 : _config$bootstrap8$fe[key];
+          }
+
+          return res;
+        }, {});
         this.featureFlags.receivedFeatureFlags({
-          featureFlags: activeFlags
+          featureFlags: activeFlags,
+          featureFlagPayloads: featureFlagPayloads
         });
       }
 
@@ -7226,6 +7274,30 @@ var PostHog = /*#__PURE__*/function () {
     value: function getFeatureFlag(key, options) {
       return this.featureFlags.getFeatureFlag(key, options);
     }
+    /*
+     * Get feature flag payload value matching key for user (supports multivariate flags).
+     *
+     * ### Usage:
+     *
+     *     if(posthog.getFeatureFlag('beta-feature') === 'some-value') {
+     *          const someValue = posthog.getFeatureFlagPayload('beta-feature')
+     *          // do something
+     *     }
+     *
+     * @param {Object|String} prop Key of the feature flag.
+     */
+
+  }, {
+    key: "getFeatureFlagPayload",
+    value: function getFeatureFlagPayload(key) {
+      var payload = this.featureFlags.getFeatureFlagPayload(key);
+
+      try {
+        return JSON.parse(payload);
+      } catch (_unused) {
+        return payload;
+      }
+    }
     /*
      * See if feature flag is enabled for user.
      *