posthog-react-native 2.1.4 → 2.2.0-alpha1

package/lib/index.d.ts

@@ -187,14 +187,61 @@ declare abstract class PostHogCore {
     shutdown(): void;
 }
 
+declare type PostHogAutocaptureNavigationTrackerOptions = {
+    routeToName?: (name: string, params: any) => string;
+    routeToProperties?: (name: string, params: any) => string;
+};
+declare type PostHogAutocaptureOptions = {
+    captureTouches?: boolean;
+    customLabelProp?: string;
+    noCaptureProp?: string;
+    maxElementsCaptured?: number;
+    ignoreLabels?: string[];
+    propsToCapture?: string[];
+    captureScreens?: boolean;
+    navigation?: PostHogAutocaptureNavigationTrackerOptions;
+    captureLifecycleEvents?: boolean;
+};
+interface PostHogCustomAppProperties {
+    /** Build number like "1.2.2" or "122" */
+    $app_build?: string | null;
+    /** Name of the app as displayed below the icon like "PostHog" */
+    $app_name?: string | null;
+    /** Namespace of the app usually like "com.posthog.app" */
+    $app_namespace?: string | null;
+    /** Human friendly app version like what a user would see in the app store like "1.2.2" */
+    $app_version?: string | null;
+    /** Manufacturer like "Apple", "Samsung" or "Android" */
+    $device_manufacturer?: string | null;
+    /** Readable model name like "iPhone 12" */
+    $device_name?: string | null;
+    /** Operating system name like iOS or Android */
+    $os_name?: string | null;
+    /** Operating system version "14.0" */
+    $os_version?: string | null;
+    /** Locale (language) of the device like "en-US" */
+    $locale?: string | null;
+    /** Timezone of the device like "Europe/Berlin" */
+    $timezone?: string | null;
+}
+interface PostHogCustomAsyncStorage {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+}
+
 declare type PostHogOptions = PosthogCoreOptions & {
     persistence?: 'memory' | 'file';
+    customAppProperties?: PostHogCustomAppProperties;
+    customAsyncStorage?: PostHogCustomAsyncStorage;
 };
 declare class PostHog extends PostHogCore {
     private _persistence;
     private _memoryStorage;
-    static initAsync(): Promise<void>;
+    private _semiAsyncStorage;
+    private _appProperties;
     constructor(apiKey: string, options?: PostHogOptions);
+    /** Await this method to ensure that all state has been loaded from the async provider */
+    initAsync(): Promise<void>;
     getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
     setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void;
     fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
@@ -207,22 +254,6 @@ declare class PostHog extends PostHogCore {
 
 declare function useLifecycleTracker(client?: PostHog): void;
 
-declare type PostHogAutocaptureNavigationTrackerOptions = {
-    routeToName?: (name: string, params: any) => string;
-    routeToProperties?: (name: string, params: any) => string;
-};
-declare type PostHogAutocaptureOptions = {
-    captureTouches?: boolean;
-    customLabelProp?: string;
-    noCaptureProp?: string;
-    maxElementsCaptured?: number;
-    ignoreLabels?: string[];
-    propsToCapture?: string[];
-    captureScreens?: boolean;
-    navigation?: PostHogAutocaptureNavigationTrackerOptions;
-    captureLifecycleEvents?: boolean;
-};
-
 declare function _useNavigationTracker(options?: PostHogAutocaptureNavigationTrackerOptions, client?: PostHog): void;
 declare const useNavigationTracker: typeof _useNavigationTracker;
 
@@ -242,4 +273,4 @@ interface PostHogProviderProps {
 }
 declare const PostHogProvider: ({ children, client, options, apiKey, autocapture, style, }: PostHogProviderProps) => JSX.Element;
 
-export { PostHog, PostHogAutocaptureNavigationTrackerOptions, PostHogAutocaptureOptions, PostHogOptions, PostHogProvider, PostHogProviderProps, PostHog as default, useFeatureFlag, useFeatureFlags, useLifecycleTracker, useNavigationTracker, usePostHog };
+export { PostHog, PostHogAutocaptureNavigationTrackerOptions, PostHogAutocaptureOptions, PostHogCustomAppProperties, PostHogCustomAsyncStorage, PostHogOptions, PostHogProvider, PostHogProviderProps, PostHog as default, useFeatureFlag, useFeatureFlags, useLifecycleTracker, useNavigationTracker, usePostHog };

package/lib/index.esm.js

@@ -1,8 +1,4 @@
 import { Platform, Dimensions, AppState, View } from 'react-native';
-import * as ExpoApplication from 'expo-application';
-import * as ExpoDevice from 'expo-device';
-import * as ExpoLocalization from 'expo-localization';
-import * as FileSystem from 'expo-file-system';
 import React, { useRef, useEffect, useState, useCallback } from 'react';
 
 /******************************************************************************
@@ -1247,6 +1243,22 @@ var PostHogMemoryStorage = /** @class */ (function () {
     return PostHogMemoryStorage;
 }());
 
+var _OptionalExpoApplication = undefined;
+
+try {
+  _OptionalExpoApplication = require('expo-application');
+} catch (e) {}
+
+var OptionalExpoApplication = _OptionalExpoApplication;
+
+var _OptionalExpoFileSystem = undefined;
+
+try {
+  _OptionalExpoFileSystem = require('expo-file-system');
+} catch (e) {}
+
+var OptionalExpoFileSystem = _OptionalExpoFileSystem;
+
 var getLegacyValues = function () {
   return __awaiter(void 0, void 0, void 0, function () {
     var posthogFileDirectory, posthogDistinctIdFile, posthogAnonymousIdFile, res, _a, _b, _c, _d, _e, _f;
@@ -1254,10 +1266,18 @@ var getLegacyValues = function () {
     return __generator(this, function (_g) {
       switch (_g.label) {
         case 0:
+          // NOTE: The old react-native lib stored data in files on the filesystem.
+          // This function takes care of pulling the legacy IDs to ensure we are using them if already present
+          if (!OptionalExpoFileSystem || !OptionalExpoApplication) {
+            return [2
+            /*return*/
+            ];
+          }
+
           if (!(Platform.OS === 'ios')) return [3
           /*break*/
           , 8];
-          posthogFileDirectory = "".concat(FileSystem.documentDirectory, "../Library/Application%20Support/").concat(ExpoApplication.applicationId, "/");
+          posthogFileDirectory = "".concat(OptionalExpoFileSystem.documentDirectory, "../Library/Application%20Support/").concat(OptionalExpoApplication.applicationId, "/");
           posthogDistinctIdFile = posthogFileDirectory + 'posthog.distinctId';
           posthogAnonymousIdFile = posthogFileDirectory + 'posthog.anonymousId';
           res = {
@@ -1273,7 +1293,7 @@ var getLegacyValues = function () {
           _c = (_b = JSON).parse;
           return [4
           /*yield*/
-          , FileSystem.readAsStringAsync(posthogDistinctIdFile)];
+          , OptionalExpoFileSystem.readAsStringAsync(posthogDistinctIdFile)];
 
         case 2:
           _a.distinctId = _c.apply(_b, [_g.sent()])['posthog.distinctId'];
@@ -1294,7 +1314,7 @@ var getLegacyValues = function () {
           _f = (_e = JSON).parse;
           return [4
           /*yield*/
-          , FileSystem.readAsStringAsync(posthogAnonymousIdFile)];
+          , OptionalExpoFileSystem.readAsStringAsync(posthogAnonymousIdFile)];
 
         case 5:
           _d.anonymousId = _f.apply(_e, [_g.sent()])['posthog.anonymousId'];
@@ -1323,115 +1343,222 @@ var getLegacyValues = function () {
 };
 
 var POSTHOG_STORAGE_KEY = '.posthog-rn.json';
-var POSTHOG_STORAGE_VERSION = 'v1';
+var POSTHOG_STORAGE_VERSION = 'v1'; // NOTE: The core prefers a synchronous storage so we mimic this by pre-loading all keys
 
-var loadStorageAsync = function () {
-  return __awaiter(void 0, void 0, void 0, function () {
-    var uri, stringContent;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          uri = (FileSystem.documentDirectory || '') + POSTHOG_STORAGE_KEY;
-          _a.label = 1;
-
-        case 1:
-          _a.trys.push([1, 3,, 4]);
+var SemiAsyncStorage =
+/** @class */
+function () {
+  function SemiAsyncStorage(asyncStorage) {
+    this._memoryCache = {};
+    this._asyncStorage = asyncStorage;
+  }
 
-          return [4
-          /*yield*/
-          , FileSystem.readAsStringAsync(uri)];
+  SemiAsyncStorage.prototype.preloadAsync = function () {
+    var _this = this;
 
-        case 2:
-          stringContent = _a.sent();
-          return [2
-          /*return*/
-          , JSON.parse(stringContent).content];
+    if (this._preloadSemiAsyncStoragePromise) {
+      return this._preloadSemiAsyncStoragePromise;
+    }
 
-        case 3:
-          _a.sent();
-          return [2
-          /*return*/
-          , {}];
+    this._preloadSemiAsyncStoragePromise = this._asyncStorage.getItem(POSTHOG_STORAGE_KEY).then(function (res) {
+      try {
+        var data = res ? JSON.parse(res).content : {};
 
-        case 4:
-          return [2
-          /*return*/
-          ];
+        for (var key in data) {
+          _this._memoryCache[key] = _this._memoryCache[key] === undefined ? data[key] : _this._memoryCache[key];
+        }
+      } catch (e) {
+        console.warn("PostHog failed to load persisted data from storage. This is likely because the storage format is. We'll reset the storage.", e);
       }
     });
-  });
-};
+    return this._preloadSemiAsyncStoragePromise;
+  };
 
-var persistStorageAsync = function (content) {
-  return __awaiter(void 0, void 0, void 0, function () {
-    var uri, data;
-    return __generator(this, function (_a) {
-      switch (_a.label) {
-        case 0:
-          uri = (FileSystem.documentDirectory || '') + POSTHOG_STORAGE_KEY;
-          data = {
-            version: POSTHOG_STORAGE_VERSION,
-            content: content
-          };
-          return [4
-          /*yield*/
-          , FileSystem.writeAsStringAsync(uri, JSON.stringify(data)).catch(function (e) {
-            console.error('PostHog failed to persist data to storage', e);
-          })];
+  SemiAsyncStorage.prototype.persist = function () {
+    var payload = {
+      version: POSTHOG_STORAGE_VERSION,
+      content: this._memoryCache
+    };
+    void this._asyncStorage.setItem(POSTHOG_STORAGE_KEY, JSON.stringify(payload));
+  };
 
-        case 1:
-          _a.sent();
+  SemiAsyncStorage.prototype.getItem = function (key) {
+    return this._memoryCache[key];
+  };
 
-          return [2
-          /*return*/
-          ];
-      }
-    });
-  });
-}; // NOTE: The core prefers a synchronous storage so we mimic this by pre-loading all keys
-
-
-var _memoryCache = {};
-var SemiAsyncStorage = {
-  getItem: function (key) {
-    return _memoryCache[key];
-  },
-  setItem: function (key, value) {
-    _memoryCache[key] = value;
-    void persistStorageAsync(_memoryCache);
-  },
-  removeItem: function (key) {
-    delete _memoryCache[key];
-    void persistStorageAsync(_memoryCache);
-  },
-  clear: function () {
-    for (var key in _memoryCache) {
-      delete _memoryCache[key];
+  SemiAsyncStorage.prototype.setItem = function (key, value) {
+    this._memoryCache[key] = value;
+    this.persist();
+  };
+
+  SemiAsyncStorage.prototype.removeItem = function (key) {
+    delete this._memoryCache[key];
+    this.persist();
+  };
+
+  SemiAsyncStorage.prototype.clear = function () {
+    for (var key in this._memoryCache) {
+      delete this._memoryCache[key];
     }
 
-    void persistStorageAsync(_memoryCache);
-  },
-  getAllKeys: function () {
-    return Object.keys(_memoryCache);
-  }
+    this.persist();
+  };
+
+  SemiAsyncStorage.prototype.getAllKeys = function () {
+    return Object.keys(this._memoryCache);
+  };
+
+  return SemiAsyncStorage;
+}();
+
+var version = "2.2.0-alpha1";
+
+var warn = function (name) {
+  console.warn("PostHog: Missing ".concat(name, " optional dependency. Some functions may not work as expected..."));
 };
 
-var _preloadSemiAsyncStoragePromise;
+var _OptionalAsyncStorage = undefined;
+
+try {
+  _OptionalAsyncStorage = require('@react-native-async-storage/async-storage').default;
+} catch (e) {
+  warn('@react-native-async-storage/async-storage');
+}
+
+var OptionalAsyncStorage = _OptionalAsyncStorage;
+
+var _OptionalExpoDevice = undefined;
+
+try {
+  _OptionalExpoDevice = require('expo-device');
+} catch (e) {}
 
-var preloadSemiAsyncStorage = function () {
-  if (_preloadSemiAsyncStoragePromise) {
-    return _preloadSemiAsyncStoragePromise;
+var OptionalExpoDevice = _OptionalExpoDevice;
+
+var _OptionalExpoLocalization = undefined;
+
+try {
+  _OptionalExpoLocalization = require('expo-localization');
+} catch (e) {}
+
+var OptionalExpoLocalization = _OptionalExpoLocalization;
+
+var _OptionalReactNativeDeviceInfo = undefined;
+
+try {
+  _OptionalReactNativeDeviceInfo = require('react-native-device-info');
+} catch (e) {
+  warn('react-native-device-info');
+}
+
+var OptionalReactNativeDeviceInfo = _OptionalReactNativeDeviceInfo;
+
+var getAppProperties = function () {
+  var properties = {};
+
+  if (OptionalExpoApplication) {
+    properties.$app_build = OptionalExpoApplication.nativeBuildVersion;
+    properties.$app_name = OptionalExpoApplication.applicationName;
+    properties.$app_namespace = OptionalExpoApplication.applicationId;
+    properties.$app_version = OptionalExpoApplication.nativeApplicationVersion;
   }
 
-  _preloadSemiAsyncStoragePromise = loadStorageAsync().then(function (res) {
-    for (var key in res) {
-      _memoryCache[key] = _memoryCache[key] === undefined ? res[key] : _memoryCache[key];
-    }
-  });
-  return _preloadSemiAsyncStoragePromise;
+  if (OptionalExpoDevice) {
+    properties.$device_manufacturer = OptionalExpoDevice.manufacturer;
+    properties.$device_name = OptionalExpoDevice.modelName;
+    properties.$os_name = OptionalExpoDevice.osName;
+    properties.$os_version = OptionalExpoDevice.osVersion;
+  }
+
+  if (OptionalExpoLocalization) {
+    properties.$locale = OptionalExpoLocalization.locale;
+    properties.$timezone = OptionalExpoLocalization.timezone;
+  }
+
+  if (OptionalReactNativeDeviceInfo) {
+    properties.$app_build = OptionalReactNativeDeviceInfo.getBuildIdSync();
+    properties.$app_name = OptionalReactNativeDeviceInfo.getApplicationName();
+    properties.$app_namespace = OptionalReactNativeDeviceInfo.getBundleId();
+    properties.$app_version = OptionalReactNativeDeviceInfo.getVersion();
+    properties.$device_manufacturer = OptionalReactNativeDeviceInfo.getManufacturerSync();
+    properties.$device_name = OptionalReactNativeDeviceInfo.getDeviceNameSync();
+    properties.$os_name = OptionalReactNativeDeviceInfo.getSystemName();
+    properties.$os_version = OptionalReactNativeDeviceInfo.getSystemVersion();
+  }
+
+  return properties;
 };
+var buildOptimisiticAsyncStorage = function () {
+  if (OptionalExpoFileSystem) {
+    var filesystem_1 = OptionalExpoFileSystem;
+    return {
+      getItem: function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+          var uri, stringContent;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                uri = (filesystem_1.documentDirectory || '') + key;
+                _a.label = 1;
+
+              case 1:
+                _a.trys.push([1, 3,, 4]);
+
+                return [4
+                /*yield*/
+                , filesystem_1.readAsStringAsync(uri)];
+
+              case 2:
+                stringContent = _a.sent();
+                return [2
+                /*return*/
+                , stringContent];
+
+              case 3:
+                _a.sent();
+                return [2
+                /*return*/
+                , null];
+
+              case 4:
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
+      },
+      setItem: function (key, value) {
+        return __awaiter(this, void 0, void 0, function () {
+          var uri;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                uri = (filesystem_1.documentDirectory || '') + key;
+                return [4
+                /*yield*/
+                , filesystem_1.writeAsStringAsync(uri, value)];
+
+              case 1:
+                _a.sent();
+
+                return [2
+                /*return*/
+                ];
+            }
+          });
+        });
+      }
+    };
+  }
 
-var version = "2.1.4";
+  if (OptionalAsyncStorage) {
+    return OptionalAsyncStorage;
+  }
+
+  console.log(OptionalAsyncStorage);
+  throw new Error('PostHog: No storage available. Please install expo-filesystem or react-native-async-storage OR implement a custom storage provider.');
+};
 
 var PostHog =
 /** @class */
@@ -1442,29 +1569,51 @@ function (_super) {
     var _this = _super.call(this, apiKey, options) || this;
 
     _this._memoryStorage = new PostHogMemoryStorage();
+    _this._appProperties = {};
     _this._persistence = options === null || options === void 0 ? void 0 : options.persistence;
+    _this._appProperties = (options === null || options === void 0 ? void 0 : options.customAppProperties) || getAppProperties();
+    _this._semiAsyncStorage = new SemiAsyncStorage((options === null || options === void 0 ? void 0 : options.customAsyncStorage) || buildOptimisiticAsyncStorage());
     AppState.addEventListener('change', function () {
       _this.flush();
     }); // Ensure the async storage has been preloaded (this call is cached)
     // It is possible that the old library was used so we try to get the legacy distinctID
 
-    void preloadSemiAsyncStorage().then(function () {
+    void _this._semiAsyncStorage.preloadAsync().then(function () {
       _this.setupBootstrap(options);
 
-      if (!SemiAsyncStorage.getItem(PostHogPersistedProperty.AnonymousId)) {
+      if (!_this._semiAsyncStorage.getItem(PostHogPersistedProperty.AnonymousId)) {
         getLegacyValues().then(function (legacyValues) {
           if (legacyValues === null || legacyValues === void 0 ? void 0 : legacyValues.distinctId) {
-            SemiAsyncStorage.setItem(PostHogPersistedProperty.DistinctId, legacyValues.distinctId);
-            SemiAsyncStorage.setItem(PostHogPersistedProperty.AnonymousId, legacyValues.anonymousId);
+            _this._semiAsyncStorage.setItem(PostHogPersistedProperty.DistinctId, legacyValues.distinctId);
+
+            _this._semiAsyncStorage.setItem(PostHogPersistedProperty.AnonymousId, legacyValues.anonymousId);
           }
         });
       }
     });
     return _this;
   }
+  /** Await this method to ensure that all state has been loaded from the async provider */
+
+
+  PostHog.prototype.initAsync = function () {
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            return [4
+            /*yield*/
+            , this._semiAsyncStorage];
 
-  PostHog.initAsync = function () {
-    return preloadSemiAsyncStorage();
+          case 1:
+            _a.sent();
+
+            return [2
+            /*return*/
+            ];
+        }
+      });
+    });
   };
 
   PostHog.prototype.getPersistedProperty = function (key) {
@@ -1472,7 +1621,7 @@ function (_super) {
       return this._memoryStorage.getProperty(key);
     }
 
-    return SemiAsyncStorage.getItem(key) || undefined;
+    return this._semiAsyncStorage.getItem(key) || undefined;
   };
 
   PostHog.prototype.setPersistedProperty = function (key, value) {
@@ -1480,7 +1629,7 @@ function (_super) {
       return this._memoryStorage.setProperty(key, value);
     }
 
-    return value !== null ? SemiAsyncStorage.setItem(key, value) : SemiAsyncStorage.removeItem(key);
+    return value !== null ? this._semiAsyncStorage.setItem(key, value) : this._semiAsyncStorage.removeItem(key);
   };
 
   PostHog.prototype.fetch = function (url, options) {
@@ -1500,20 +1649,10 @@ function (_super) {
   };
 
   PostHog.prototype.getCommonEventProperties = function () {
-    return __assign(__assign({}, _super.prototype.getCommonEventProperties.call(this)), {
-      $app_build: '1',
-      $app_name: ExpoApplication.applicationName,
-      $app_namespace: ExpoApplication.applicationId,
-      $app_version: ExpoApplication.nativeApplicationVersion,
-      $device_manufacturer: ExpoDevice.manufacturer,
-      $device_name: ExpoDevice.modelName,
+    return __assign(__assign(__assign({}, _super.prototype.getCommonEventProperties.call(this)), this._appProperties), {
       $device_type: Platform.OS,
-      $locale: ExpoLocalization.locale,
-      $os_name: ExpoDevice.osName,
-      $os_version: ExpoDevice.osVersion,
       $screen_height: Dimensions.get('screen').height,
-      $screen_width: Dimensions.get('screen').width,
-      $timezone: ExpoLocalization.timezone
+      $screen_width: Dimensions.get('screen').width
     });
   }; // Custom methods
 
@@ -1526,9 +1665,6 @@ function (_super) {
 
   return PostHog;
 }(PostHogCore);
-// is used
-
-void PostHog.initAsync();
 
 var PostHogContext = /*#__PURE__*/React.createContext({
   client: undefined
@@ -1573,10 +1709,6 @@ function useLifecycleTracker(client) {
 
 var _OptionalReactNativeNavigation = undefined;
 
-var warn = function (name) {
-  console.warn("PostHog: Missing ".concat(name, " optional dependency. Some functions may not work as expected..."));
-};
-
 try {
   _OptionalReactNativeNavigation = require('@react-navigation/native');
 } catch (e) {