posthog-js-lite 2.0.0-alpha5 → 2.0.1

package/lib/index.esm.js

@@ -127,18 +127,33 @@ 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 PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
+    PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
     PostHogPersistedProperty["DistinctId"] = "distinct_id";
     PostHogPersistedProperty["Props"] = "props";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
+    PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
     PostHogPersistedProperty["Queue"] = "queue";
     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) {
@@ -696,13 +711,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.requestTimeout = (_e = options === null || options === void 0 ? void 0 : options.requestTimeout) !== null && _e !== void 0 ? _e : 10000; // 10 seconds
         this._sessionExpirationTimeSeconds = (_f = options === null || options === void 0 ? void 0 : options.sessionExpirationTimeSeconds) !== null && _f !== void 0 ? _f : 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) {
@@ -713,12 +728,35 @@ 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);
+    };
+    PostHogCore.prototype.setupBootstrap = function (options) {
+        var _a, _b, _c, _d;
+        if ((_a = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _a === void 0 ? void 0 : _a.distinctId) {
+            if ((_b = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _b === void 0 ? void 0 : _b.isIdentifiedId) {
+                this.setPersistedProperty(PostHogPersistedProperty.DistinctId, options.bootstrap.distinctId);
+            }
+            else {
+                this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, options.bootstrap.distinctId);
+            }
+        }
+        if ((_c = options === null || options === void 0 ? void 0 : options.bootstrap) === null || _c === void 0 ? void 0 : _c.featureFlags) {
+            var activeFlags = Object.keys(((_d = options.bootstrap) === null || _d === void 0 ? void 0 : _d.featureFlags) || {})
+                .filter(function (flag) { var _a, _b; return !!((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[flag]); })
+                .reduce(function (res, key) {
+                var _a, _b;
+                return ((res[key] = ((_b = (_a = options.bootstrap) === null || _a === void 0 ? void 0 : _a.featureFlags) === null || _b === void 0 ? void 0 : _b[key]) || false), res);
+            }, {});
+            this.setKnownFeatureFlags(activeFlags);
+            (options === null || options === void 0 ? void 0 : options.bootstrap.featureFlagPayloads) && this.setKnownFeatureFlagPayloads(options === null || options === void 0 ? void 0 : options.bootstrap.featureFlagPayloads);
+        }
     };
     Object.defineProperty(PostHogCore.prototype, "props", {
         // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
@@ -734,6 +772,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;
@@ -751,11 +792,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;
@@ -785,13 +831,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);
@@ -805,32 +854,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) {
@@ -860,11 +916,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;
@@ -880,66 +935,151 @@ var PostHogCore = /** @class */ (function () {
         return this;
     };
     PostHogCore.prototype.groupIdentify = function (groupType, groupKey, groupProperties) {
-        var payload = {
+        var payload = this.buildPayload({
             event: '$groupidentify',
-            distinctId: "$".concat(groupType, "_").concat(groupKey),
             properties: __assign({ $group_type: groupType, $group_key: groupKey, $group_set: groupProperties || {} }, this.getCommonEventProperties()),
-        };
+        });
         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");
+                url = "".concat(this.host, "/decide/?v=3");
                 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);
+                        var newFeatureFlags = res.featureFlags;
+                        var newFeatureFlagPayloads = res.featureFlagPayloads;
+                        if (res.errorsWhileComputingFlags) {
+                            // if not all flags were computed, we upsert flags instead of replacing them
+                            var currentFlags = _this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+                            var currentFlagPayloads = _this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+                            newFeatureFlags = __assign(__assign({}, currentFlags), res.featureFlags);
+                            newFeatureFlagPayloads = __assign(__assign({}, currentFlagPayloads), res.featureFlagPayloads);
+                        }
+                        _this.setKnownFeatureFlags(newFeatureFlags);
+                        _this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads);
                     }
-                    _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.setKnownFeatureFlags = function (featureFlags) {
+        this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
+        this._events.emit('featureflags', featureFlags);
+    };
+    PostHogCore.prototype.setKnownFeatureFlagPayloads = function (featureFlagPayloads) {
+        this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads, featureFlagPayloads);
+    };
+    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];
+        // `/decide` v3 returns all flags
+        if (response === undefined) {
+            // For cases where the flag is unknown, return 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.getFeatureFlagPayload = function (key) {
+        var payloads = this.getFeatureFlagPayloads();
+        if (!payloads) {
+            return undefined;
+        }
+        var response = payloads[key];
+        // Undefined means a loading or missing data issue. Null means evaluation happened and there was no match
+        if (response === undefined) {
+            return null;
+        }
+        return this._parsePayload(response);
+    };
+    PostHogCore.prototype.getFeatureFlagPayloads = function () {
+        var _this = this;
+        var payloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+        if (payloads) {
+            return Object.fromEntries(Object.entries(payloads).map(function (_a) {
+                var k = _a[0], v = _a[1];
+                return [k, _this._parsePayload(v)];
+            }));
+        }
+        return payloads;
+    };
+    PostHogCore.prototype._parsePayload = function (response) {
+        try {
+            return JSON.parse(response);
+        }
+        catch (_a) {
+            return response;
+        }
     };
     PostHogCore.prototype.getFeatureFlags = function () {
         var flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
@@ -958,35 +1098,34 @@ 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.getFeatureFlagsAndPayloads = function () {
+        var flags = this.getFeatureFlags();
+        var payloads = this.getFeatureFlagPayloads();
+        return {
+            flags: flags,
+            payloads: payloads,
+        };
     };
-    PostHogCore.prototype.reloadFeatureFlagsAsync = function () {
+    PostHogCore.prototype.isFeatureEnabled = function (key) {
+        var response = this.getFeatureFlag(key);
+        if (response === undefined) {
+            return undefined;
+        }
+        return !!response;
+    };
+    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) {
@@ -998,12 +1137,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
      ***/
@@ -1032,13 +1192,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);
@@ -1046,7 +1208,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);
@@ -1093,10 +1255,19 @@ var PostHogCore = /** @class */ (function () {
         });
     };
     PostHogCore.prototype.fetchWithRetry = function (url, options, retryOptions) {
+        var _a;
+        var _b;
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            return __generator(this, function (_a) {
-                return [2 /*return*/, retriable(function () { return _this.fetch(url, options); }, retryOptions || this._retryOptions)];
+            return __generator(this, function (_c) {
+                (_a = (_b = AbortSignal).timeout) !== null && _a !== void 0 ? _a : (_b.timeout = function timeout(ms) {
+                    var ctrl = new AbortController();
+                    setTimeout(function () { return ctrl.abort(); }, ms);
+                    return ctrl.signal;
+                });
+                return [2 /*return*/, retriable(function () {
+                        return _this.fetch(url, __assign({ signal: AbortSignal.timeout(_this.requestTimeout) }, options));
+                    }, retryOptions || this._retryOptions)];
             });
         });
     };
@@ -1105,7 +1276,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:
@@ -1121,7 +1291,7 @@ var PostHogCore = /** @class */ (function () {
     return PostHogCore;
 }());
 
-var version = "2.0.0-alpha5";
+var version = "2.0.1";
 
 function getContext(window) {
   var context = {};
@@ -1382,9 +1552,6 @@ var createStorageLike = function (store) {
   };
 };
 
-var _localStore = createStorageLike(window.localStorage);
-var _sessionStore = createStorageLike(window.sessionStorage);
-
 var checkStoreIsSupported = function (storage, key) {
   if (key === void 0) {
     key = '__mplssupport__';
@@ -1409,8 +1576,8 @@ var checkStoreIsSupported = function (storage, key) {
   }
 };
 
-var localStore = checkStoreIsSupported(_localStore) ? _localStore : undefined;
-var sessionStorage = checkStoreIsSupported(_sessionStore) ? _sessionStore : undefined;
+var localStore = undefined;
+var sessionStore = undefined;
 
 var createMemoryStorage = function () {
   var _cache = {};
@@ -1442,16 +1609,30 @@ var createMemoryStorage = function () {
   return store;
 };
 
-var getStorage = function (type) {
+var getStorage = function (type, window) {
+  if (window) {
+    if (!localStorage) {
+      var _localStore = createStorageLike(window.localStorage);
+
+      localStore = checkStoreIsSupported(_localStore) ? _localStore : undefined;
+    }
+
+    if (!sessionStore) {
+      var _sessionStore = createStorageLike(window.sessionStorage);
+
+      sessionStore = checkStoreIsSupported(_sessionStore) ? _sessionStore : undefined;
+    }
+  }
+
   switch (type) {
     case 'cookie':
-      return cookieStore || localStore || sessionStorage || createMemoryStorage();
+      return cookieStore || localStore || sessionStore || createMemoryStorage();
 
     case 'localStorage':
-      return localStore || sessionStorage || createMemoryStorage();
+      return localStore || sessionStore || createMemoryStorage();
 
     case 'sessionStorage':
-      return sessionStorage || createMemoryStorage();
+      return sessionStore || createMemoryStorage();
 
     case 'memory':
       return createMemoryStorage();
@@ -1471,7 +1652,10 @@ function (_super) {
 
 
     _this._storageKey = (options === null || options === void 0 ? void 0 : options.persistence_name) ? "ph_".concat(options.persistence_name) : "ph_".concat(apiKey, "_posthog");
-    _this._storage = getStorage((options === null || options === void 0 ? void 0 : options.persistence) || 'localStorage');
+    _this._storage = getStorage((options === null || options === void 0 ? void 0 : options.persistence) || 'localStorage', window);
+
+    _this.setupBootstrap(options);
+
     return _this;
   }