posthog-react-native 2.0.0 → 2.1.0

package/lib/index.d.ts

@@ -23,7 +23,9 @@ declare enum PostHogPersistedProperty {
     Queue = "queue",
     OptedOut = "opted_out",
     SessionId = "session_id",
-    SessionLastTimestamp = "session_timestamp"
+    SessionLastTimestamp = "session_timestamp",
+    PersonProperties = "person_properties",
+    GroupProperties = "group_properties"
 }
 declare type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -85,7 +87,7 @@ declare class SimpleEventEmitter {
 
 declare abstract class PostHogCore {
     private apiKey;
-    private host;
+    host: string;
     private flushAt;
     private flushInterval;
     private captureMode;
@@ -108,12 +110,13 @@ declare abstract class PostHogCore {
     protected getCommonEventProperties(): any;
     private get props();
     private set props(value);
+    private clearProps;
     private _props;
     get optedOut(): boolean;
     optIn(): void;
     optOut(): void;
     on(event: string, cb: (...args: any[]) => void): () => void;
-    reset(): void;
+    reset(propertiesToKeep?: PostHogPersistedProperty[]): void;
     debug(enabled?: boolean): void;
     private buildPayload;
     getSessionId(): string | undefined;
@@ -130,7 +133,7 @@ declare abstract class PostHogCore {
     identify(distinctId?: string, properties?: PostHogEventProperties): this;
     capture(event: string, properties?: {
         [key: string]: any;
-    }): this;
+    }, forceSendFeatureFlags?: boolean): this;
     alias(alias: string): this;
     autocapture(eventType: string, elements: PostHogAutocaptureElement[], properties?: PostHogEventProperties): this;
     /***
@@ -141,18 +144,30 @@ declare abstract class PostHogCore {
     }): this;
     group(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
     groupIdentify(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
+    /***
+     * PROPERTIES
+     ***/
+    personProperties(properties: {
+        [type: string]: string;
+    }): this;
+    groupProperties(properties: {
+        [type: string]: Record<string, string>;
+    }): this;
     /***
      *** FEATURE FLAGS
      ***/
     private decideAsync;
     private _decideAsync;
-    getFeatureFlag(key: string, defaultResult?: string | boolean): boolean | string | undefined;
+    getFeatureFlag(key: string): boolean | string | undefined;
     getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
-    isFeatureEnabled(key: string, defaultResult?: boolean): boolean;
-    reloadFeatureFlagsAsync(): Promise<PostHogDecideResponse['featureFlags']>;
+    isFeatureEnabled(key: string): boolean | undefined;
+    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags']>;
     onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
     onFeatureFlag(key: string, cb: (value: string | boolean) => void): () => void;
     overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): void;
+    _sendFeatureFlags(event: string, properties?: {
+        [key: string]: any;
+    }): void;
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -195,7 +210,9 @@ declare type PostHogAutocaptureOptions = {
     maxElementsCaptured?: number;
     ignoreLabels?: string[];
     propsToCapture?: string[];
+    captureScreens?: boolean;
     navigation?: PostHogAutocaptureNavigationTrackerOptions;
+    captureLifecycleEvents?: boolean;
 };
 
 declare function _useNavigationTracker(options?: PostHogAutocaptureNavigationTrackerOptions, client?: PostHog): void;
@@ -203,7 +220,7 @@ declare const useNavigationTracker: typeof _useNavigationTracker;
 
 declare function useFeatureFlags(client?: PostHog): PostHogDecideResponse$1['featureFlags'] | undefined;
 
-declare function useFeatureFlag(flag: string, defaultValue?: boolean | string): string | boolean | undefined;
+declare function useFeatureFlag(flag: string): string | boolean | undefined;
 
 declare const usePostHog: () => PostHog | undefined;
 

package/lib/index.esm.js

@@ -134,6 +134,17 @@ 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;
@@ -147,6 +158,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) {
@@ -720,12 +733,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
@@ -741,6 +756,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;
@@ -758,9 +776,15 @@ 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);
+            }
         }
     };
     PostHogCore.prototype.debug = function (enabled) {
@@ -835,12 +859,18 @@ var PostHogCore = /** @class */ (function () {
         this.enqueue('identify', payload);
         return this;
     };
-    PostHogCore.prototype.capture = function (event, properties) {
+    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) {
@@ -870,7 +900,6 @@ 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),
         });
@@ -898,31 +927,58 @@ 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({
                         token: this.apiKey,
                         distinct_id: distinctId,
-                        $anon_distinct_id: this.getAnonymousId(),
+                        $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
                         groups: groups,
+                        person_properties: personProperties,
+                        group_properties: groupProperties,
                     }),
                 };
                 this._decideResponsePromise = this.fetchWithRetry(url, fetchOptions)
@@ -941,23 +997,26 @@ var PostHogCore = /** @class */ (function () {
             });
         });
     };
-    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);
@@ -976,17 +1035,19 @@ 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 () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.decideAsync()];
+                    case 0: return [4 /*yield*/, this.decideAsync(sendAnonDistinctId)];
                     case 1: return [2 /*return*/, (_a.sent()).featureFlags];
                 }
             });
@@ -1024,6 +1085,14 @@ var PostHogCore = /** @class */ (function () {
         }
         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
      ***/
@@ -1052,13 +1121,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);
@@ -1066,7 +1137,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);
@@ -1337,7 +1408,7 @@ var preloadSemiAsyncStorage = function () {
   return _preloadSemiAsyncStoragePromise;
 };
 
-var version = "2.0.0";
+var version = "2.1.0";
 
 var PostHog =
 /** @class */
@@ -1574,10 +1645,10 @@ function useFeatureFlags(client) {
   return featureFlags;
 }
 
-function useFeatureFlag(flag, defaultValue) {
+function useFeatureFlag(flag) {
   var posthog = usePostHog();
 
-  var _a = useState(posthog === null || posthog === void 0 ? void 0 : posthog.getFeatureFlag(flag, defaultValue)),
+  var _a = useState(posthog === null || posthog === void 0 ? void 0 : posthog.getFeatureFlag(flag)),
       featureFlag = _a[0],
       setFeatureFlag = _a[1];
 
@@ -1586,11 +1657,11 @@ function useFeatureFlag(flag, defaultValue) {
   }
 
   useEffect(function () {
-    setFeatureFlag(posthog.getFeatureFlag(flag, defaultValue));
+    setFeatureFlag(posthog.getFeatureFlag(flag));
     return posthog.onFeatureFlags(function () {
-      setFeatureFlag(posthog.getFeatureFlag(flag, defaultValue));
+      setFeatureFlag(posthog.getFeatureFlag(flag));
     });
-  }, [posthog, flag, defaultValue]);
+  }, [posthog, flag]);
   return featureFlag;
 }
 
@@ -1705,14 +1776,20 @@ var autocaptureFromTouchEvent = function (e, posthog, options) {
   }
 };
 
-function PostHogHooks(_a) {
+function PostHogNavigationHook(_a) {
   var options = _a.options;
   useNavigationTracker(options === null || options === void 0 ? void 0 : options.navigation);
+  return null;
+}
+
+function PostHogLifecycleHook() {
   useLifecycleTracker();
   return null;
 }
 
 var PostHogProvider = function (_a) {
+  var _b, _c;
+
   var children = _a.children,
       client = _a.client,
       options = _a.options,
@@ -1725,10 +1802,13 @@ var PostHogProvider = function (_a) {
     posthogRef.current = client ? client : apiKey ? new PostHog(apiKey, options) : undefined;
   }
 
-  var autocaptureEnabled = !!autocapture;
   var autocaptureOptions = autocapture && typeof autocapture !== 'boolean' ? autocapture : {};
   var posthog = posthogRef.current;
   var captureTouches = posthog && (autocapture === true || (autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureTouches));
+  var captureScreens = posthog && (autocapture === true || ((_b = autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureScreens) !== null && _b !== void 0 ? _b : true)); // Default to true if not set
+
+  var captureLifecycle = posthog && (autocapture === true || ((_c = autocaptureOptions === null || autocaptureOptions === void 0 ? void 0 : autocaptureOptions.captureLifecycleEvents) !== null && _c !== void 0 ? _c : true)); // Default to true if not set
+
   var onTouch = useCallback(function (type, e) {
     // TODO: Improve this to ensure we only capture presses and not just ends of a drag for example
     if (!captureTouches) {
@@ -1738,8 +1818,7 @@ var PostHogProvider = function (_a) {
     if (type === 'end') {
       autocaptureFromTouchEvent(e, posthog, autocaptureOptions);
     }
-  }, [posthog, autocapture]); // TODO: Improve this to ensure we only capture presses and not just ends of a drag for example
-
+  }, [posthog, autocapture]);
   return /*#__PURE__*/React.createElement(View, {
     "ph-label": "PostHogProvider",
     style: style || {
@@ -1752,9 +1831,9 @@ var PostHogProvider = function (_a) {
     value: {
       client: posthogRef.current
     }
-  }, autocaptureEnabled ? /*#__PURE__*/React.createElement(PostHogHooks, {
+  }, /*#__PURE__*/React.createElement(React.Fragment, null, captureScreens ? /*#__PURE__*/React.createElement(PostHogNavigationHook, {
     options: autocaptureOptions
-  }) : null, children));
+  }) : null, captureLifecycle ? /*#__PURE__*/React.createElement(PostHogLifecycleHook, null) : null), children));
 };
 
 export { PostHog, PostHogProvider, PostHog as default, useFeatureFlag, useFeatureFlags, useLifecycleTracker, useNavigationTracker, usePostHog };