posthog-node 2.0.0-alpha7 → 2.0.1

package/lib/index.cjs.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var undici = require('undici');
+var crypto = require('crypto');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -137,12 +138,24 @@ function __generator(thisArg, body) {
             throw op[1];
         return { value: op[0] ? op[1] : void 0, done: true };
     }
+}
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar)
+                    ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+    return to.concat(ar || Array.prototype.slice.call(from));
 }
 
-var version = "2.0.0-alpha7";
+var version = "2.0.1";
 
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
+    PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
     PostHogPersistedProperty["DistinctId"] = "distinct_id";
     PostHogPersistedProperty["Props"] = "props";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
@@ -151,6 +164,8 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["OptedOut"] = "opted_out";
     PostHogPersistedProperty["SessionId"] = "session_id";
     PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
+    PostHogPersistedProperty["PersonProperties"] = "person_properties";
+    PostHogPersistedProperty["GroupProperties"] = "group_properties";
 })(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
 
 function assert(truthyValue, message) {
@@ -697,7 +712,7 @@ var SimpleEventEmitter = /** @class */ (function () {
 var PostHogCore = /** @class */ (function () {
     function PostHogCore(apiKey, options) {
         var _this = this;
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         this.flagCallReported = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -708,14 +723,13 @@ var PostHogCore = /** @class */ (function () {
         this.flushInterval = (_a = options === null || options === void 0 ? void 0 : options.flushInterval) !== null && _a !== void 0 ? _a : 10000;
         this.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'form';
         this.sendFeatureFlagEvent = (_b = options === null || options === void 0 ? void 0 : options.sendFeatureFlagEvent) !== null && _b !== void 0 ? _b : true;
-        this._decidePollInterval = Math.max(0, (_c = options === null || options === void 0 ? void 0 : options.decidePollInterval) !== null && _c !== void 0 ? _c : 30000);
         // If enable is explicitly set to false we override the optout
         this._optoutOverride = (options === null || options === void 0 ? void 0 : options.enable) === false;
         this._retryOptions = {
-            retryCount: (_d = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _d !== void 0 ? _d : 3,
-            retryDelay: (_e = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _e !== void 0 ? _e : 3000,
+            retryCount: (_c = options === null || options === void 0 ? void 0 : options.fetchRetryCount) !== null && _c !== void 0 ? _c : 3,
+            retryDelay: (_d = options === null || options === void 0 ? void 0 : options.fetchRetryDelay) !== null && _d !== void 0 ? _d : 3000,
         };
-        this._sessionExpirationTimeSeconds = (_f = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _f !== void 0 ? _f : 1800; // 30 minutes
+        this._sessionExpirationTimeSeconds = (_e = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _e !== void 0 ? _e : 1800; // 30 minutes
         // NOTE: It is important we don't initiate anything in the constructor as some async IO may still be underway on the parent
         if ((options === null || options === void 0 ? void 0 : options.preloadFeatureFlags) !== false) {
             safeSetTimeout(function () {
@@ -725,12 +739,14 @@ var PostHogCore = /** @class */ (function () {
     }
     PostHogCore.prototype.getCommonEventProperties = function () {
         var featureFlags = this.getFeatureFlags();
-        return {
-            $lib: this.getLibraryId(),
-            $lib_version: this.getLibraryVersion(),
-            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
-            $enabled_feature_flags: featureFlags,
-        };
+        var featureVariantProperties = {};
+        if (featureFlags) {
+            for (var _i = 0, _a = Object.entries(featureFlags); _i < _a.length; _i++) {
+                var _b = _a[_i], feature = _b[0], variant = _b[1];
+                featureVariantProperties["$feature/".concat(feature)] = variant;
+            }
+        }
+        return __assign({ $lib: this.getLibraryId(), $lib_version: this.getLibraryVersion(), $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined }, featureVariantProperties);
     };
     Object.defineProperty(PostHogCore.prototype, "props", {
         // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
@@ -746,6 +762,9 @@ var PostHogCore = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    PostHogCore.prototype.clearProps = function () {
+        this.props = undefined;
+    };
     Object.defineProperty(PostHogCore.prototype, "optedOut", {
         get: function () {
             var _a, _b;
@@ -763,11 +782,16 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.on = function (event, cb) {
         return this._events.on(event, cb);
     };
-    PostHogCore.prototype.reset = function () {
-        for (var key in PostHogPersistedProperty) {
-            this.setPersistedProperty(PostHogPersistedProperty[key], null);
+    PostHogCore.prototype.reset = function (propertiesToKeep) {
+        var allPropertiesToKeep = __spreadArray([PostHogPersistedProperty.Queue], (propertiesToKeep || []), true);
+        // clean up props
+        this.clearProps();
+        for (var _i = 0, _a = Object.keys(PostHogPersistedProperty); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) {
+                this.setPersistedProperty(PostHogPersistedProperty[key], null);
+            }
         }
-        this.setPersistedProperty(PostHogPersistedProperty.DistinctId, generateUUID(globalThis));
     };
     PostHogCore.prototype.debug = function (enabled) {
         var _a;
@@ -797,13 +821,16 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.resetSessionId = function () {
         this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
     };
-    PostHogCore.prototype.getDistinctId = function () {
-        var distinctId = this.getPersistedProperty(PostHogPersistedProperty.DistinctId);
-        if (!distinctId) {
-            distinctId = generateUUID(globalThis);
-            this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
+    PostHogCore.prototype.getAnonymousId = function () {
+        var anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+        if (!anonId) {
+            anonId = generateUUID(globalThis);
+            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, anonId);
         }
-        return distinctId;
+        return anonId;
+    };
+    PostHogCore.prototype.getDistinctId = function () {
+        return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
     };
     PostHogCore.prototype.register = function (properties) {
         this.props = __assign(__assign({}, this.props), properties);
@@ -817,32 +844,39 @@ var PostHogCore = /** @class */ (function () {
      *** TRACKING
      ***/
     PostHogCore.prototype.identify = function (distinctId, properties) {
-        distinctId = distinctId || this.getDistinctId();
+        var previousDistinctId = this.getDistinctId();
+        distinctId = distinctId || previousDistinctId;
         if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
             this.groups(properties.$groups);
         }
         var payload = __assign(__assign({}, this.buildPayload({
             distinct_id: distinctId,
             event: '$identify',
-            properties: __assign(__assign({}, (properties || {})), { $anon_distinct_id: this.getDistinctId() }),
+            properties: __assign(__assign({}, (properties || {})), { $anon_distinct_id: this.getAnonymousId() }),
         })), { $set: properties });
-        if (distinctId !== this.getDistinctId()) {
+        if (distinctId !== previousDistinctId) {
+            // We keep the AnonymousId to be used by decide calls and identify to link the previousId
+            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
             this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
+            if (this.getFeatureFlags()) {
+                void this.reloadFeatureFlagsAsync();
+            }
         }
         this.enqueue('identify', payload);
         return this;
     };
-    PostHogCore.prototype.capture = function (event, properties) {
-        // NOTE: Legacy nodejs implementation uses groups
-        if (properties && properties['groups']) {
-            properties.$groups = properties.groups;
-            delete properties.groups;
-        }
+    PostHogCore.prototype.capture = function (event, properties, forceSendFeatureFlags) {
+        if (forceSendFeatureFlags === void 0) { forceSendFeatureFlags = false; }
         if (properties === null || properties === void 0 ? void 0 : properties.$groups) {
             this.groups(properties.$groups);
         }
-        var payload = this.buildPayload({ event: event, properties: properties });
-        this.enqueue('capture', payload);
+        if (forceSendFeatureFlags) {
+            this._sendFeatureFlags(event, properties);
+        }
+        else {
+            var payload = this.buildPayload({ event: event, properties: properties });
+            this.enqueue('capture', payload);
+        }
         return this;
     };
     PostHogCore.prototype.alias = function (alias) {
@@ -872,11 +906,10 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.groups = function (groups) {
         // Get persisted groups
         var existingGroups = this.props.$groups || {};
-        // NOTE: Should we do the same for groups listed in identify / capture?
         this.register({
             $groups: __assign(__assign({}, existingGroups), groups),
         });
-        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; }) && this._decideResponsePromise) {
+        if (Object.keys(groups).find(function (type) { return existingGroups[type] !== groups[type]; }) && this.getFeatureFlags()) {
             void this.reloadFeatureFlagsAsync();
         }
         return this;
@@ -900,58 +933,96 @@ var PostHogCore = /** @class */ (function () {
         this.enqueue('capture', payload);
         return this;
     };
+    /***
+     * PROPERTIES
+     ***/
+    PostHogCore.prototype.personProperties = function (properties) {
+        // Get persisted person properties
+        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+        this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, __assign(__assign({}, existingProperties), properties));
+        return this;
+    };
+    PostHogCore.prototype.groupProperties = function (properties) {
+        // Get persisted group properties
+        var existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
+        if (Object.keys(existingProperties).length !== 0) {
+            Object.keys(existingProperties).forEach(function (groupType) {
+                existingProperties[groupType] = __assign(__assign({}, existingProperties[groupType]), properties[groupType]);
+                delete properties[groupType];
+            });
+        }
+        this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, __assign(__assign({}, existingProperties), properties));
+        return this;
+    };
     /***
      *** FEATURE FLAGS
      ***/
-    PostHogCore.prototype.decideAsync = function () {
+    PostHogCore.prototype.decideAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         if (this._decideResponsePromise) {
             return this._decideResponsePromise;
         }
-        return this._decideAsync();
+        return this._decideAsync(sendAnonDistinctId);
     };
-    PostHogCore.prototype._decideAsync = function () {
+    PostHogCore.prototype._decideAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var url, distinctId, groups, fetchOptions;
+            var url, distinctId, groups, personProperties, groupProperties, fetchOptions;
             var _this = this;
             return __generator(this, function (_a) {
                 url = "".concat(this.host, "/decide/?v=2");
                 distinctId = this.getDistinctId();
                 groups = this.props.$groups || {};
+                personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+                groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
                 fetchOptions = {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ groups: groups, distinct_id: distinctId, token: this.apiKey }),
+                    body: JSON.stringify({
+                        token: this.apiKey,
+                        distinct_id: distinctId,
+                        $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
+                        groups: groups,
+                        person_properties: personProperties,
+                        group_properties: groupProperties,
+                    }),
                 };
                 this._decideResponsePromise = this.fetchWithRetry(url, fetchOptions)
                     .then(function (r) { return r.json(); })
                     .then(function (res) {
                     if (res.featureFlags) {
                         _this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, res.featureFlags);
+                        _this._events.emit('featureflags', res.featureFlags);
                     }
-                    _this._events.emit('featureflags', res.featureFlags);
                     return res;
+                })
+                    .finally(function () {
+                    _this._decideResponsePromise = undefined;
                 });
                 return [2 /*return*/, this._decideResponsePromise];
             });
         });
     };
-    PostHogCore.prototype.getFeatureFlag = function (key, defaultResult) {
-        var _a;
-        if (defaultResult === void 0) { defaultResult = false; }
+    PostHogCore.prototype.getFeatureFlag = function (key) {
         var featureFlags = this.getFeatureFlags();
         if (!featureFlags) {
-            // If we haven't loaded flags yet we respond undefined to indicate this
+            // If we haven't loaded flags yet, or errored out, we respond with undefined
             return undefined;
         }
+        var response = featureFlags[key];
+        if (response === undefined) {
+            // `/decide` returns nothing for flags which are false.
+            response = false;
+        }
         if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
             this.flagCallReported[key] = true;
             this.capture('$feature_flag_called', {
                 $feature_flag: key,
-                $feature_flag_response: featureFlags[key],
+                $feature_flag_response: response,
             });
         }
-        // If we have flags we either return the value (true or string) or the defaultResult
-        return (_a = featureFlags[key]) !== null && _a !== void 0 ? _a : defaultResult;
+        // If we have flags we either return the value (true or string) or false
+        return response;
     };
     PostHogCore.prototype.getFeatureFlags = function () {
         var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
@@ -970,35 +1041,26 @@ var PostHogCore = /** @class */ (function () {
         }
         return flags;
     };
-    PostHogCore.prototype.isFeatureEnabled = function (key, defaultResult) {
-        var _a;
-        if (defaultResult === void 0) { defaultResult = false; }
-        var flag = (_a = this.getFeatureFlag(key, defaultResult)) !== null && _a !== void 0 ? _a : defaultResult;
-        return !!flag;
+    PostHogCore.prototype.isFeatureEnabled = function (key) {
+        var response = this.getFeatureFlag(key);
+        if (response === undefined) {
+            return undefined;
+        }
+        return !!response;
     };
-    PostHogCore.prototype.reloadFeatureFlagsAsync = function () {
+    PostHogCore.prototype.reloadFeatureFlagsAsync = function (sendAnonDistinctId) {
+        if (sendAnonDistinctId === void 0) { sendAnonDistinctId = true; }
         return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        clearTimeout(this._decideTimer);
-                        if (this._decidePollInterval) {
-                            this._decideTimer = safeSetTimeout(function () { return _this.reloadFeatureFlagsAsync(); }, this._decidePollInterval);
-                        }
-                        this._decideResponsePromise = undefined;
-                        return [4 /*yield*/, this.decideAsync()];
+                    case 0: return [4 /*yield*/, this.decideAsync(sendAnonDistinctId)];
                     case 1: return [2 /*return*/, (_a.sent()).featureFlags];
                 }
             });
         });
     };
-    // When listening to feature flags polling is active
     PostHogCore.prototype.onFeatureFlags = function (cb) {
         var _this = this;
-        if (!this._decideTimer) {
-            void this.reloadFeatureFlagsAsync();
-        }
         return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
             var flags;
             return __generator(this, function (_a) {
@@ -1010,12 +1072,33 @@ var PostHogCore = /** @class */ (function () {
             });
         }); });
     };
+    PostHogCore.prototype.onFeatureFlag = function (key, cb) {
+        var _this = this;
+        return this.on('featureflags', function () { return __awaiter(_this, void 0, void 0, function () {
+            var flagResponse;
+            return __generator(this, function (_a) {
+                flagResponse = this.getFeatureFlag(key);
+                if (flagResponse !== undefined) {
+                    cb(flagResponse);
+                }
+                return [2 /*return*/];
+            });
+        }); });
+    };
     PostHogCore.prototype.overrideFeatureFlag = function (flags) {
         if (flags === null) {
             return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
         }
         return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
     };
+    PostHogCore.prototype._sendFeatureFlags = function (event, properties) {
+        var _this = this;
+        this.reloadFeatureFlagsAsync(false).finally(function () {
+            // Try to enqueue message irrespective of errors during feature flag fetching
+            var payload = _this.buildPayload({ event: event, properties: properties });
+            _this.enqueue('capture', payload);
+        });
+    };
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -1044,13 +1127,15 @@ var PostHogCore = /** @class */ (function () {
     PostHogCore.prototype.flushAsync = function () {
         var _this = this;
         return new Promise(function (resolve, reject) {
-            _this.flush(function (err, data) { return (err ? reject(err) : resolve(data)); });
+            _this.flush(function (err, data) {
+                return err ? reject(err) : resolve(data);
+            });
         });
     };
     PostHogCore.prototype.flush = function (callback) {
         var _this = this;
         if (this.optedOut) {
-            return callback && safeSetTimeout(callback, 0);
+            return callback === null || callback === void 0 ? void 0 : callback();
         }
         if (this._flushTimer) {
             clearTimeout(this._flushTimer);
@@ -1058,7 +1143,7 @@ var PostHogCore = /** @class */ (function () {
         }
         var queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
-            return callback && safeSetTimeout(callback, 0);
+            return callback === null || callback === void 0 ? void 0 : callback();
         }
         var items = queue.splice(0, this.flushAt);
         this.setPersistedProperty(PostHogPersistedProperty.Queue, queue);
@@ -1117,7 +1202,6 @@ var PostHogCore = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        clearTimeout(this._decideTimer);
                         clearTimeout(this._flushTimer);
                         return [4 /*yield*/, this.flushAsync()];
                     case 1:
@@ -1146,6 +1230,553 @@ var PostHogMemoryStorage = /** @class */ (function () {
     return PostHogMemoryStorage;
 }());
 
+var LONG_SCALE = 0xfffffffffffffff;
+
+var ClientError =
+/** @class */
+function (_super) {
+  __extends(ClientError, _super);
+
+  function ClientError(message) {
+    var _this = _super.call(this) || this;
+
+    Error.captureStackTrace(_this, _this.constructor);
+    _this.name = 'ClientError';
+    _this.message = message;
+    Object.setPrototypeOf(_this, ClientError.prototype);
+    return _this;
+  }
+
+  return ClientError;
+}(Error);
+
+var InconclusiveMatchError =
+/** @class */
+function (_super) {
+  __extends(InconclusiveMatchError, _super);
+
+  function InconclusiveMatchError(message) {
+    var _this = _super.call(this, message) || this;
+
+    _this.name = _this.constructor.name;
+    Error.captureStackTrace(_this, _this.constructor); // instanceof doesn't work in ES3 or ES5
+    // https://www.dannyguo.com/blog/how-to-fix-instanceof-not-working-for-custom-errors-in-typescript/
+    // this is the workaround
+
+    Object.setPrototypeOf(_this, InconclusiveMatchError.prototype);
+    return _this;
+  }
+
+  return InconclusiveMatchError;
+}(Error);
+
+var FeatureFlagsPoller =
+/** @class */
+function () {
+  function FeatureFlagsPoller(_a) {
+    var pollingInterval = _a.pollingInterval,
+        personalApiKey = _a.personalApiKey,
+        projectApiKey = _a.projectApiKey,
+        timeout = _a.timeout,
+        host = _a.host;
+    this.pollingInterval = pollingInterval;
+    this.personalApiKey = personalApiKey;
+    this.featureFlags = [];
+    this.groupTypeMapping = {};
+    this.loadedSuccessfullyOnce = false;
+    this.timeout = timeout;
+    this.projectApiKey = projectApiKey;
+    this.host = host;
+    this.poller = undefined;
+    void this.loadFeatureFlags();
+  }
+
+  FeatureFlagsPoller.prototype.getFeatureFlag = function (key, distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var response, featureFlag, _i, _a, flag;
+
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this.loadFeatureFlags()];
+
+          case 1:
+            _b.sent();
+
+            response = undefined;
+            featureFlag = undefined;
+
+            if (!this.loadedSuccessfullyOnce) {
+              return [2
+              /*return*/
+              , response];
+            }
+
+            for (_i = 0, _a = this.featureFlags; _i < _a.length; _i++) {
+              flag = _a[_i];
+
+              if (key === flag.key) {
+                featureFlag = flag;
+                break;
+              }
+            }
+
+            if (featureFlag !== undefined) {
+              try {
+                response = this.computeFlagLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
+                console.debug("Successfully computed flag locally: ".concat(key, " -> ").concat(response));
+              } catch (e) {
+                if (e instanceof InconclusiveMatchError) {
+                  console.debug("Can't compute flag locally: ".concat(key, ": ").concat(e));
+                } else if (e instanceof Error) {
+                  console.error("Error computing flag locally: ".concat(key, ": ").concat(e));
+                }
+              }
+            }
+
+            return [2
+            /*return*/
+            , response];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.getAllFlags = function (distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      var response, fallbackToDecide;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this.loadFeatureFlags()];
+
+          case 1:
+            _a.sent();
+
+            response = {};
+            fallbackToDecide = this.featureFlags.length == 0;
+            this.featureFlags.map(function (flag) {
+              try {
+                response[flag.key] = _this.computeFlagLocally(flag, distinctId, groups, personProperties, groupProperties);
+              } catch (e) {
+                if (e instanceof InconclusiveMatchError) ; else if (e instanceof Error) {
+                  console.error("Error computing flag locally: ".concat(flag.key, ": ").concat(e));
+                }
+
+                fallbackToDecide = true;
+              }
+            });
+            return [2
+            /*return*/
+            , {
+              response: response,
+              fallbackToDecide: fallbackToDecide
+            }];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.computeFlagLocally = function (flag, distinctId, groups, personProperties, groupProperties) {
+    if (groups === void 0) {
+      groups = {};
+    }
+
+    if (personProperties === void 0) {
+      personProperties = {};
+    }
+
+    if (groupProperties === void 0) {
+      groupProperties = {};
+    }
+
+    if (flag.ensure_experience_continuity) {
+      throw new InconclusiveMatchError('Flag has experience continuity enabled');
+    }
+
+    if (!flag.active) {
+      return false;
+    }
+
+    var flagFilters = flag.filters || {};
+    var aggregation_group_type_index = flagFilters.aggregation_group_type_index;
+
+    if (aggregation_group_type_index != undefined) {
+      var groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
+
+      if (!groupName) {
+        console.warn("[FEATURE FLAGS] Unknown group type index ".concat(aggregation_group_type_index, " for feature flag ").concat(flag.key));
+        throw new InconclusiveMatchError('Flag has unknown group type index');
+      }
+
+      if (!(groupName in groups)) {
+        console.warn("[FEATURE FLAGS] Can't compute group feature flag: ".concat(flag.key, " without group names passed in"));
+        return false;
+      }
+
+      var focusedGroupProperties = groupProperties[groupName];
+      return this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties);
+    } else {
+      return this.matchFeatureFlagProperties(flag, distinctId, personProperties);
+    }
+  };
+
+  FeatureFlagsPoller.prototype.matchFeatureFlagProperties = function (flag, distinctId, properties) {
+    var _this = this;
+
+    var flagFilters = flag.filters || {};
+    var flagConditions = flagFilters.groups || [];
+    var isInconclusive = false;
+    var result = undefined;
+    flagConditions.forEach(function (condition) {
+      try {
+        if (_this.isConditionMatch(flag, distinctId, condition, properties)) {
+          result = _this.getMatchingVariant(flag, distinctId) || true;
+        }
+      } catch (e) {
+        if (e instanceof InconclusiveMatchError) {
+          isInconclusive = true;
+        } else {
+          throw e;
+        }
+      }
+    });
+
+    if (result !== undefined) {
+      return result;
+    } else if (isInconclusive) {
+      throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
+    } // We can only return False when all conditions are False
+
+
+    return false;
+  };
+
+  FeatureFlagsPoller.prototype.isConditionMatch = function (flag, distinctId, condition, properties) {
+    var rolloutPercentage = condition.rollout_percentage;
+
+    if ((condition.properties || []).length > 0) {
+      var matchAll = condition.properties.every(function (property) {
+        return matchProperty(property, properties);
+      });
+
+      if (!matchAll) {
+        return false;
+      } else if (rolloutPercentage == undefined) {
+        // == to include `null` as a match, not just `undefined`
+        return true;
+      }
+    }
+
+    if (rolloutPercentage != undefined && _hash(flag.key, distinctId) > rolloutPercentage / 100.0) {
+      return false;
+    }
+
+    return true;
+  };
+
+  FeatureFlagsPoller.prototype.getMatchingVariant = function (flag, distinctId) {
+    var hashValue = _hash(flag.key, distinctId, 'variant');
+
+    var matchingVariant = this.variantLookupTable(flag).find(function (variant) {
+      return hashValue >= variant.valueMin && hashValue < variant.valueMax;
+    });
+
+    if (matchingVariant) {
+      return matchingVariant.key;
+    }
+
+    return undefined;
+  };
+
+  FeatureFlagsPoller.prototype.variantLookupTable = function (flag) {
+    var _a;
+
+    var lookupTable = [];
+    var valueMin = 0;
+    var valueMax = 0;
+    var flagFilters = flag.filters || {};
+    var multivariates = ((_a = flagFilters.multivariate) === null || _a === void 0 ? void 0 : _a.variants) || [];
+    multivariates.forEach(function (variant) {
+      valueMax = valueMin + variant.rollout_percentage / 100.0;
+      lookupTable.push({
+        valueMin: valueMin,
+        valueMax: valueMax,
+        key: variant.key
+      });
+      valueMin = valueMax;
+    });
+    return lookupTable;
+  };
+
+  FeatureFlagsPoller.prototype.loadFeatureFlags = function (forceReload) {
+    if (forceReload === void 0) {
+      forceReload = false;
+    }
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (!(!this.loadedSuccessfullyOnce || forceReload)) return [3
+            /*break*/
+            , 2];
+            return [4
+            /*yield*/
+            , this._loadFeatureFlags()];
+
+          case 1:
+            _a.sent();
+
+            _a.label = 2;
+
+          case 2:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype._loadFeatureFlags = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var res, responseJson, err_1;
+
+      var _this = this;
+
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (this.poller) {
+              clearTimeout(this.poller);
+              this.poller = undefined;
+            }
+
+            this.poller = setTimeout(function () {
+              return _this._loadFeatureFlags();
+            }, this.pollingInterval);
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 4,, 5]);
+
+            return [4
+            /*yield*/
+            , this._requestFeatureFlagDefinitions()];
+
+          case 2:
+            res = _a.sent();
+
+            if (res && res.statusCode === 401) {
+              throw new ClientError("Your personalApiKey is invalid. Are you sure you're not using your Project API key? More information: https://posthog.com/docs/api/overview");
+            }
+
+            return [4
+            /*yield*/
+            , res.body.json()];
+
+          case 3:
+            responseJson = _a.sent();
+
+            if (!('flags' in responseJson)) {
+              console.error("Invalid response when getting feature flags: ".concat(JSON.stringify(responseJson)));
+            }
+
+            this.featureFlags = responseJson.flags || [];
+            this.groupTypeMapping = responseJson.group_type_mapping || {};
+            this.loadedSuccessfullyOnce = true;
+            return [3
+            /*break*/
+            , 5];
+
+          case 4:
+            err_1 = _a.sent(); // if an error that is not an instance of ClientError is thrown
+            // we silently ignore the error when reloading feature flags
+
+            if (err_1 instanceof ClientError) {
+              throw err_1;
+            }
+
+            return [3
+            /*break*/
+            , 5];
+
+          case 5:
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype._requestFeatureFlagDefinitions = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      var url, headers, options, res, err_2;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            url = "".concat(this.host, "/api/feature_flag/local_evaluation?token=").concat(this.projectApiKey);
+            headers = {
+              'Content-Type': 'application/json',
+              Authorization: "Bearer ".concat(this.personalApiKey),
+              'user-agent': "posthog-node/".concat(version)
+            };
+            options = {
+              method: 'GET',
+              headers: headers
+            };
+
+            if (this.timeout && typeof this.timeout === 'number') {
+              options.bodyTimeout = this.timeout;
+            }
+
+            _a.label = 1;
+
+          case 1:
+            _a.trys.push([1, 3,, 4]);
+
+            return [4
+            /*yield*/
+            , undici.request(url, options)];
+
+          case 2:
+            res = _a.sent();
+            return [3
+            /*break*/
+            , 4];
+
+          case 3:
+            err_2 = _a.sent();
+            throw new Error("Request failed with error: ".concat(err_2));
+
+          case 4:
+            return [2
+            /*return*/
+            , res];
+        }
+      });
+    });
+  };
+
+  FeatureFlagsPoller.prototype.stopPoller = function () {
+    clearTimeout(this.poller);
+  };
+
+  return FeatureFlagsPoller;
+}(); // # This function takes a distinct_id and a feature flag key and returns a float between 0 and 1.
+// # Given the same distinct_id and key, it'll always return the same float. These floats are
+// # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
+// # we can do _hash(key, distinct_id) < 0.2
+
+
+function _hash(key, distinctId, salt) {
+  if (salt === void 0) {
+    salt = '';
+  }
+
+  var sha1Hash = crypto.createHash('sha1');
+  sha1Hash.update("".concat(key, ".").concat(distinctId).concat(salt));
+  return parseInt(sha1Hash.digest('hex').slice(0, 15), 16) / LONG_SCALE;
+}
+
+function matchProperty(property, propertyValues) {
+  var key = property.key;
+  var value = property.value;
+  var operator = property.operator || 'exact';
+
+  if (!(key in propertyValues)) {
+    throw new InconclusiveMatchError("Property ".concat(key, " not found in propertyValues"));
+  } else if (operator === 'is_not_set') {
+    throw new InconclusiveMatchError("Operator is_not_set is not supported");
+  }
+
+  var overrideValue = propertyValues[key];
+
+  switch (operator) {
+    case 'exact':
+      return Array.isArray(value) ? value.indexOf(overrideValue) !== -1 : value === overrideValue;
+
+    case 'is_not':
+      return Array.isArray(value) ? value.indexOf(overrideValue) === -1 : value !== overrideValue;
+
+    case 'is_set':
+      return key in propertyValues;
+
+    case 'icontains':
+      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+
+    case 'not_icontains':
+      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+
+    case 'regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null;
+
+    case 'not_regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null;
+
+    case 'gt':
+      return typeof overrideValue == typeof value && overrideValue > value;
+
+    case 'gte':
+      return typeof overrideValue == typeof value && overrideValue >= value;
+
+    case 'lt':
+      return typeof overrideValue == typeof value && overrideValue < value;
+
+    case 'lte':
+      return typeof overrideValue == typeof value && overrideValue <= value;
+
+    default:
+      console.error("Unknown operator: ".concat(operator));
+      return false;
+  }
+}
+
+function isValidRegex(regex) {
+  try {
+    new RegExp(regex);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+var THIRTY_SECONDS = 30 * 1000;
+var MAX_CACHE_SIZE = 50 * 1000;
+
 var PostHog =
 /** @class */
 function (_super) {
@@ -1161,6 +1792,8 @@ function (_super) {
     options.captureMode = (options === null || options === void 0 ? void 0 : options.captureMode) || 'json';
     options.preloadFeatureFlags = false; // Don't preload as this makes no sense without a distinctId
 
+    options.sendFeatureFlagEvent = false; // Let `posthog-node` handle this on its own, since we're dealing with multiple distinctIDs
+
     _this = _super.call(this, apiKey, options) || this;
     _this._memoryStorage = new PostHogMemoryStorage();
     return _this;
@@ -1207,20 +1840,25 @@ function () {
       options = {};
     }
 
-    options.decidePollInterval = 0; // Forcefully set to 0 so we don't auto-reload
-
     this._sharedClient = new PostHog(apiKey, options);
+
+    if (options.personalApiKey) {
+      this.featureFlagsPoller = new FeatureFlagsPoller({
+        pollingInterval: typeof options.featureFlagsPollingInterval === 'number' ? options.featureFlagsPollingInterval : THIRTY_SECONDS,
+        personalApiKey: options.personalApiKey,
+        projectApiKey: apiKey,
+        timeout: options.requestTimeout,
+        host: this._sharedClient.host
+      });
+    }
+
+    this.distinctIdHasSentFlagCalls = {};
+    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
   }
 
   PostHogGlobal.prototype.reInit = function (distinctId) {
-    // Certain properties we want to persist
-    var propertiesToKeep = [PostHogPersistedProperty.Queue, PostHogPersistedProperty.OptedOut];
-
-    for (var key in PostHogPersistedProperty) {
-      if (!propertiesToKeep.includes(key)) {
-        this._sharedClient.setPersistedProperty(PostHogPersistedProperty[key], null);
-      }
-    }
+    // Certain properties we want to persist. Queue is persisted always by default.
+    this._sharedClient.reset([PostHogPersistedProperty.OptedOut]);
 
     this._sharedClient.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
   };
@@ -1237,14 +1875,15 @@ function () {
     var distinctId = _a.distinctId,
         event = _a.event,
         properties = _a.properties,
-        groups = _a.groups;
+        groups = _a.groups,
+        sendFeatureFlags = _a.sendFeatureFlags;
     this.reInit(distinctId);
 
     if (groups) {
       this._sharedClient.groups(groups);
     }
 
-    this._sharedClient.capture(event, properties);
+    this._sharedClient.capture(event, properties, sendFeatureFlags || false);
   };
 
   PostHogGlobal.prototype.identify = function (_a) {
@@ -1261,33 +1900,95 @@ function () {
     this._sharedClient.alias(data.alias);
   };
 
-  PostHogGlobal.prototype.getFeatureFlag = function (key, distinctId, groups) {
+  PostHogGlobal.prototype.getFeatureFlag = function (key, distinctId, options) {
+    var _a;
+
     return __awaiter(this, void 0, void 0, function () {
-      return __generator(this, function (_a) {
-        switch (_a.label) {
+      var _b, groups, personProperties, groupProperties, _c, onlyEvaluateLocally, sendFeatureFlagEvents, response, flagWasLocallyEvaluated, featureFlagReportedKey;
+
+      return __generator(this, function (_d) {
+        switch (_d.label) {
           case 0:
+            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties;
+            _c = options || {}, onlyEvaluateLocally = _c.onlyEvaluateLocally, sendFeatureFlagEvents = _c.sendFeatureFlagEvents; // set defaults
+
+            if (onlyEvaluateLocally == undefined) {
+              onlyEvaluateLocally = false;
+            }
+
+            if (sendFeatureFlagEvents == undefined) {
+              sendFeatureFlagEvents = true;
+            }
+
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties)];
+
+          case 1:
+            response = _d.sent();
+            flagWasLocallyEvaluated = response !== undefined;
+            if (!(!flagWasLocallyEvaluated && !onlyEvaluateLocally)) return [3
+            /*break*/
+            , 3];
             this.reInit(distinctId);
 
-            if (groups) {
+            if (groups != undefined) {
               this._sharedClient.groups(groups);
             }
 
+            if (personProperties) {
+              this._sharedClient.personProperties(personProperties);
+            }
+
+            if (groupProperties) {
+              this._sharedClient.groupProperties(groupProperties);
+            }
+
             return [4
             /*yield*/
-            , this._sharedClient.reloadFeatureFlagsAsync()];
+            , this._sharedClient.reloadFeatureFlagsAsync(false)];
 
-          case 1:
-            _a.sent();
+          case 2:
+            _d.sent();
+
+            response = this._sharedClient.getFeatureFlag(key);
+            _d.label = 3;
+
+          case 3:
+            featureFlagReportedKey = "".concat(key, "_").concat(response);
+
+            if (sendFeatureFlagEvents && (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey))) {
+              if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) {
+                this.distinctIdHasSentFlagCalls = {};
+              }
+
+              if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) {
+                this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
+              } else {
+                this.distinctIdHasSentFlagCalls[distinctId] = [featureFlagReportedKey];
+              }
+
+              this.capture({
+                distinctId: distinctId,
+                event: '$feature_flag_called',
+                properties: {
+                  $feature_flag: key,
+                  $feature_flag_response: response,
+                  locally_evaluated: flagWasLocallyEvaluated
+                },
+                groups: groups
+              });
+            }
 
             return [2
             /*return*/
-            , this._sharedClient.getFeatureFlag(key)];
+            , response];
         }
       });
     });
   };
 
-  PostHogGlobal.prototype.isFeatureEnabled = function (key, distinctId, defaultResult, groups) {
+  PostHogGlobal.prototype.isFeatureEnabled = function (key, distinctId, options) {
     return __awaiter(this, void 0, void 0, function () {
       var feat;
       return __generator(this, function (_a) {
@@ -1295,13 +1996,88 @@ function () {
           case 0:
             return [4
             /*yield*/
-            , this.getFeatureFlag(key, distinctId, groups)];
+            , this.getFeatureFlag(key, distinctId, options)];
 
           case 1:
             feat = _a.sent();
+
+            if (feat === undefined) {
+              return [2
+              /*return*/
+              , undefined];
+            }
+
             return [2
             /*return*/
-            , !!feat || defaultResult || false];
+            , !!feat || false];
+        }
+      });
+    });
+  };
+
+  PostHogGlobal.prototype.getAllFlags = function (distinctId, options) {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      var _b, groups, personProperties, groupProperties, onlyEvaluateLocally, localEvaluationResult, response, fallbackToDecide, remoteEvaluationResult;
+
+      return __generator(this, function (_c) {
+        switch (_c.label) {
+          case 0:
+            _b = options || {}, groups = _b.groups, personProperties = _b.personProperties, groupProperties = _b.groupProperties;
+            onlyEvaluateLocally = (options || {}).onlyEvaluateLocally; // set defaults
+
+            if (onlyEvaluateLocally == undefined) {
+              onlyEvaluateLocally = false;
+            }
+
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.getAllFlags(distinctId, groups, personProperties, groupProperties)];
+
+          case 1:
+            localEvaluationResult = _c.sent();
+            response = {};
+            fallbackToDecide = true;
+
+            if (localEvaluationResult) {
+              response = localEvaluationResult.response;
+              fallbackToDecide = localEvaluationResult.fallbackToDecide;
+            }
+
+            if (!(fallbackToDecide && !onlyEvaluateLocally)) return [3
+            /*break*/
+            , 3];
+            this.reInit(distinctId);
+
+            if (groups) {
+              this._sharedClient.groups(groups);
+            }
+
+            if (personProperties) {
+              this._sharedClient.personProperties(personProperties);
+            }
+
+            if (groupProperties) {
+              this._sharedClient.groupProperties(groupProperties);
+            }
+
+            return [4
+            /*yield*/
+            , this._sharedClient.reloadFeatureFlagsAsync(false)];
+
+          case 2:
+            _c.sent();
+
+            remoteEvaluationResult = this._sharedClient.getFeatureFlags();
+            return [2
+            /*return*/
+            , __assign(__assign({}, response), remoteEvaluationResult)];
+
+          case 3:
+            return [2
+            /*return*/
+            , response];
         }
       });
     });
@@ -1316,15 +2092,50 @@ function () {
   };
 
   PostHogGlobal.prototype.reloadFeatureFlags = function () {
-    throw new Error('Method not implemented.');
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.loadFeatureFlags(true)];
+
+          case 1:
+            _b.sent();
+
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
+  };
+
+  PostHogGlobal.prototype.flush = function () {
+    this._sharedClient.flush();
   };
 
   PostHogGlobal.prototype.shutdown = function () {
-    void this._sharedClient.shutdownAsync();
+    void this.shutdownAsync();
   };
 
   PostHogGlobal.prototype.shutdownAsync = function () {
-    return this._sharedClient.shutdownAsync();
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_b) {
+        (_a = this.featureFlagsPoller) === null || _a === void 0 ? void 0 : _a.stopPoller();
+        return [2
+        /*return*/
+        , this._sharedClient.shutdownAsync()];
+      });
+    });
+  };
+
+  PostHogGlobal.prototype.debug = function (enabled) {
+    return this._sharedClient.debug(enabled);
   };
 
   return PostHogGlobal;