mixpanel-react-native 3.2.0-beta.3 → 3.2.0

package/ios/MixpanelReactNative.swift

@@ -18,39 +18,16 @@ open class MixpanelReactNative: NSObject {
                     properties: [String: Any],
                     serverURL: String,
                     useGzipCompression: Bool = false,
-                    featureFlagsOptions: [String: Any]?,
                     resolver resolve: RCTPromiseResolveBlock,
                     rejecter reject: RCTPromiseRejectBlock) -> Void {
         let autoProps = properties // copy
         AutomaticProperties.setAutomaticProperties(autoProps)
         let propsProcessed = MixpanelTypeHandler.processProperties(properties: autoProps)
-
-        // Handle feature flags options
-        var featureFlagsEnabled = false
-        var featureFlagsContext: [String: Any]? = nil
-
-        if let flagsOptions = featureFlagsOptions {
-            featureFlagsEnabled = flagsOptions["enabled"] as? Bool ?? false
-            featureFlagsContext = flagsOptions["context"] as? [String: Any]
-        }
-
-        // Create MixpanelOptions with all configuration including feature flags
-        let options = MixpanelOptions(
-            token: token,
-            flushInterval: Constants.DEFAULT_FLUSH_INTERVAL,
-            instanceName: token,
-            trackAutomaticEvents: trackAutomaticEvents,
-            optOutTrackingByDefault: optOutTrackingByDefault,
-            useUniqueDistinctId: false,
-            superProperties: propsProcessed,
-            serverURL: serverURL,
-            proxyServerConfig: nil,
-            useGzipCompression: useGzipCompression,
-            featureFlagsEnabled: featureFlagsEnabled,
-            featureFlagsContext: featureFlagsContext ?? [:]
-        )
-
-        Mixpanel.initialize(options: options)
+        Mixpanel.initialize(token: token, trackAutomaticEvents: trackAutomaticEvents, flushInterval: Constants.DEFAULT_FLUSH_INTERVAL,
+                            instanceName: token, optOutTrackingByDefault: optOutTrackingByDefault,
+                            superProperties: propsProcessed,
+                            serverURL: serverURL,
+                            useGzipCompression: useGzipCompression)
         resolve(true)
     }
 
@@ -483,159 +460,4 @@ open class MixpanelReactNative: NSObject {
         return Mixpanel.getInstance(name: token)
     }
 
-    // MARK: - Feature Flags
-
-    @objc
-    func loadFlags(_ token: String,
-                   resolver resolve: RCTPromiseResolveBlock,
-                   rejecter reject: RCTPromiseRejectBlock) -> Void {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            resolve(nil)
-            return
-        }
-        flags.loadFlags()
-        resolve(nil)
-    }
-
-    @objc
-    func areFlagsReadySync(_ token: String) -> NSNumber {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token) else {
-            NSLog("[Mixpanel - areFlagsReadySync: instance is nil for token: \(token)]")
-            return NSNumber(value: false)
-        }
-
-        guard let flags = instance.flags else {
-            NSLog("[Mixpanel - areFlagsReadySync: flags is nil")
-            return NSNumber(value: false)
-        }
-
-        let ready = flags.areFlagsReady()
-        NSLog("[Mixpanel - areFlagsReadySync: flags ready = \(ready)")
-        return NSNumber(value: ready)
-    }
-
-    @objc
-    func getVariantSync(_ token: String,
-                        featureName: String,
-                        fallback: [String: Any]) -> [String: Any] {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            return fallback
-        }
-
-        let fallbackVariant = convertDictToVariant(fallback)
-        let variant = flags.getVariantSync(featureName, fallback: fallbackVariant)
-        return convertVariantToDict(variant)
-    }
-
-    @objc
-    func getVariantValueSync(_ token: String,
-                             featureName: String,
-                             fallbackValue: Any) -> Any {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            return fallbackValue
-        }
-
-        return flags.getVariantValueSync(featureName, fallbackValue: fallbackValue) ?? fallbackValue
-    }
-
-    @objc
-    func isEnabledSync(_ token: String,
-                       featureName: String,
-                       fallbackValue: Bool) -> NSNumber {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            return NSNumber(value: fallbackValue)
-        }
-
-        let enabled = flags.isEnabledSync(featureName, fallbackValue: fallbackValue)
-        return NSNumber(value: enabled)
-    }
-
-    @objc
-    func getVariant(_ token: String,
-                    featureName: String,
-                    fallback: [String: Any],
-                    resolver resolve: @escaping RCTPromiseResolveBlock,
-                    rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            resolve(fallback)
-            return
-        }
-
-        let fallbackVariant = convertDictToVariant(fallback)
-        flags.getVariant(featureName, fallback: fallbackVariant) { variant in
-            resolve(self.convertVariantToDict(variant))
-        }
-    }
-
-    @objc
-    func getVariantValue(_ token: String,
-                         featureName: String,
-                         fallbackValue: Any,
-                         resolver resolve: @escaping RCTPromiseResolveBlock,
-                         rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            resolve(fallbackValue)
-            return
-        }
-
-        flags.getVariantValue(featureName, fallbackValue: fallbackValue) { value in
-            resolve(value)
-        }
-    }
-
-    @objc
-    func isEnabled(_ token: String,
-                   featureName: String,
-                   fallbackValue: Bool,
-                   resolver resolve: @escaping RCTPromiseResolveBlock,
-                   rejecter reject: @escaping RCTPromiseRejectBlock) -> Void {
-        guard let instance = MixpanelReactNative.getMixpanelInstance(token),
-              let flags = instance.flags else {
-            resolve(fallbackValue)
-            return
-        }
-
-        flags.isEnabled(featureName, fallbackValue: fallbackValue) { isEnabled in
-            resolve(isEnabled)
-        }
-    }
-
-    // Helper methods for variant conversion
-    private func convertDictToVariant(_ dict: [String: Any]) -> MixpanelFlagVariant {
-        let key = dict["key"] as? String ?? ""
-        let value = dict["value"] ?? NSNull()
-        let experimentID = dict["experimentID"] as? String
-        let isExperimentActive = dict["isExperimentActive"] as? Bool
-        let isQATester = dict["isQATester"] as? Bool
-
-        return MixpanelFlagVariant(
-            key: key,
-            value: value,
-            isExperimentActive: isExperimentActive,
-            isQATester: isQATester,
-            experimentID: experimentID
-        )
-    }
-
-    private func convertVariantToDict(_ variant: MixpanelFlagVariant) -> [String: Any] {
-        var dict: [String: Any] = [
-            "key": variant.key,
-            "value": variant.value ?? NSNull()
-        ]
-
-        if let experimentID = variant.experimentID {
-            dict["experimentID"] = experimentID
-        }
-        dict["isExperimentActive"] = variant.isExperimentActive
-        dict["isQATester"] = variant.isQATester
-
-        return dict
-    }
-
 }

package/javascript/mixpanel-main.js

@@ -21,17 +21,10 @@ export default class MixpanelMain {
     trackAutomaticEvents = false,
     optOutTrackingDefault = false,
     superProperties = null,
-    serverURL = "https://api.mixpanel.com",
-    useGzipCompression = false,
-    featureFlagsOptions = {}
+    serverURL = "https://api.mixpanel.com"
   ) {
     MixpanelLogger.log(token, `Initializing Mixpanel`);
 
-    // Store feature flags options for later use
-    this.featureFlagsOptions = featureFlagsOptions;
-    this.featureFlagsEnabled = featureFlagsOptions.enabled || false;
-    this.featureFlagsContext = featureFlagsOptions.context || {};
-
     await this.mixpanelPersistent.initializationCompletePromise(token);
     if (optOutTrackingDefault) {
       await this.optOutTracking(token);
@@ -44,11 +37,6 @@ export default class MixpanelMain {
     await this.registerSuperProperties(token, {
       ...superProperties,
     });
-
-    // Initialize feature flags if enabled
-    if (this.featureFlagsEnabled) {
-      MixpanelLogger.log(token, "Feature flags enabled during initialization");
-    }
   }
 
   getMetaData() {
@@ -82,14 +70,6 @@ export default class MixpanelMain {
     await this.mixpanelPersistent.reset(token);
   }
 
-  /**
-   * Get the feature flags context that was provided during initialization
-   * @returns {object} The feature flags context object
-   */
-  getFeatureFlagsContext() {
-    return this.featureFlagsContext || {};
-  }
-
   async track(token, eventName, properties) {
     if (this.mixpanelPersistent.getOptedOut(token)) {
       MixpanelLogger.log(

package/javascript/mixpanel-network.js

@@ -15,77 +15,37 @@ export const MixpanelNetwork = (() => {
     serverURL,
     useIPAddressForGeoLocation,
     retryCount = 0,
-    headers = {},
   }) => {
     retryCount = retryCount || 0;
-    // Use & if endpoint already has query params, otherwise use ?
-    const separator = endpoint.includes('?') ? '&' : '?';
-    const url = `${serverURL}${endpoint}${separator}ip=${+useIPAddressForGeoLocation}`;
+    const url = `${serverURL}${endpoint}?ip=${+useIPAddressForGeoLocation}`;
     MixpanelLogger.log(token, `Sending request to: ${url}`);
 
     try {
-      // Determine if this is a GET or POST request based on data presence
-      const isGetRequest = data === null || data === undefined;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: `data=${encodeURIComponent(JSON.stringify(data))}`,
+      });
 
-      const fetchOptions = isGetRequest
-        ? {
-            method: "GET",
-            headers: headers,
-          }
-        : {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/x-www-form-urlencoded",
-              ...headers,
-            },
-            body: `data=${encodeURIComponent(JSON.stringify(data))}`,
-          };
-
-      const response = await fetch(url, fetchOptions);
-
-      // Handle GET requests differently - they return the data directly
-      if (isGetRequest) {
-        if (response.status === 200) {
-          const responseData = await response.json();
-          MixpanelLogger.log(token, `GET request successful: ${endpoint}`);
-          return responseData;
-        } else {
-          throw new MixpanelHttpError(
-            `HTTP error! status: ${response.status}`,
-            response.status
-          );
-        }
-      } else {
-        // Handle POST requests (existing logic)
-        const responseBody = await response.json();
-        if (response.status !== 200) {
-          throw new MixpanelHttpError(
-            `HTTP error! status: ${response.status}`,
-            response.status
-          );
-        }
-
-        const message =
-          responseBody === 0
-            ? `${url} api rejected some items`
-            : `Mixpanel batch sent successfully, endpoint: ${endpoint}, data: ${JSON.stringify(
-                data
-              )}`;
-
-        MixpanelLogger.log(token, message);
-        return responseBody;
+      const responseBody = await response.json();
+      if (response.status !== 200) {
+        throw new MixpanelHttpError(
+          `HTTP error! status: ${response.status}`,
+          response.status
+        );
       }
-    } catch (error) {
-      // Determine if this is a GET or POST request
-      const isGetRequest = data === null || data === undefined;
 
-      // For GET requests (like flags), don't retry on 404 or other client errors
-      if (isGetRequest && error.code >= 400 && error.code < 500) {
-        MixpanelLogger.log(token, `GET request failed with status ${error.code}, not retrying`);
-        throw error;
-      }
+      const message =
+        responseBody === 0
+          ? `${url} api rejected some items`
+          : `Mixpanel batch sent successfully, endpoint: ${endpoint}, data: ${JSON.stringify(
+              data
+            )}`;
 
-      // For POST requests or non-client errors, handle retries
+      MixpanelLogger.log(token, message);
+    } catch (error) {
       if (error.code === 400) {
         // This indicates that the data was invalid and we should not retry
         throw new MixpanelHttpError(
@@ -93,35 +53,30 @@ export const MixpanelNetwork = (() => {
           error.code
         );
       }
-
       MixpanelLogger.warn(
         token,
         `API request to ${url} has failed with reason: ${error.message}`
       );
-
-      // Only retry for POST requests or server errors
-      if (!isGetRequest || error.code >= 500) {
-        const maxRetries = 5;
-        const backoff = Math.min(2 ** retryCount * 2000, 60000); // Exponential backoff
-        if (retryCount < maxRetries) {
-          MixpanelLogger.log(token, `Retrying in ${backoff / 1000} seconds...`);
-          await new Promise((resolve) => setTimeout(resolve, backoff));
-          return sendRequest({
-            token,
-            endpoint,
-            data,
-            serverURL,
-            useIPAddressForGeoLocation,
-            retryCount: retryCount + 1,
-          });
-        }
+      const maxRetries = 5;
+      const backoff = Math.min(2 ** retryCount * 2000, 60000); // Exponential backoff
+      if (retryCount < maxRetries) {
+        MixpanelLogger.log(token, `Retrying in ${backoff / 1000} seconds...`);
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+        return sendRequest({
+          token,
+          endpoint,
+          data,
+          serverURL,
+          useIPAddressForGeoLocation,
+          retryCount: retryCount + 1,
+        });
+      } else {
+        MixpanelLogger.warn(token, `Max retries reached. Giving up.`);
+        throw new MixpanelHttpError(
+          `HTTP error! status: ${error.code}`,
+          error.code
+        );
       }
-
-      MixpanelLogger.warn(token, `Request failed. Not retrying.`);
-      throw new MixpanelHttpError(
-        `HTTP error! status: ${error.code || 'unknown'}`,
-        error.code
-      );
     }
   };
 

package/javascript/mixpanel-persistent.js

@@ -11,41 +11,9 @@ import {
 
 import "react-native-get-random-values"; // Polyfill for crypto.getRandomValues
 import { AsyncStorageAdapter } from "./mixpanel-storage";
-import uuid from "uuid";
+import { v4 as uuidv4 } from "uuid";
 import { MixpanelLogger } from "mixpanel-react-native/javascript/mixpanel-logger";
 
-/**
- * Generate a UUID v4, with cross-platform fallbacks
- * Tries: uuid package → Web Crypto API → manual generation
- */
-function generateUUID() {
-  // Try uuid package first (works in React Native with polyfill)
-  try {
-    const result = uuid.v4();
-    if (result) return result;
-  } catch (e) {
-    // Fall through to alternatives
-  }
-
-  // Try Web Crypto API (modern browsers)
-  const cryptoObj =
-    (typeof globalThis !== "undefined" && globalThis.crypto) ||
-    (typeof window !== "undefined" && window.crypto) ||
-    (typeof crypto !== "undefined" && crypto);
-
-  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
-    return cryptoObj.randomUUID();
-  }
-
-  // Last resort: manual UUID v4 generation using Math.random
-  // Less secure but functional for device IDs
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-    const r = (Math.random() * 16) | 0;
-    const v = c === "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-}
-
 export class MixpanelPersistent {
   static instance;
 
@@ -74,7 +42,7 @@ export class MixpanelPersistent {
   }
 
   async initializationCompletePromise(token) {
-    return Promise.all([
+    await Promise.all([
       this.loadIdentity(token),
       this.loadSuperProperties(token),
       this.loadTimeEvents(token),
@@ -99,8 +67,8 @@ export class MixpanelPersistent {
     this._identity[token].deviceId = storageToken;
 
     if (!this._identity[token].deviceId) {
-      // Generate device ID with cross-platform UUID generation
-      this._identity[token].deviceId = generateUUID();
+      // Generate device ID using uuidv4() with polyfilled crypto.getRandomValues
+      this._identity[token].deviceId = uuidv4();
       await this.storageAdapter.setItem(
         getDeviceIdKey(token),
         this._identity[token].deviceId

package/javascript/mixpanel-storage.js

@@ -12,9 +12,9 @@ export class AsyncStorageAdapter {
         }
       } catch {
         console.error(
-          "[@RNC/AsyncStorage]: NativeModule: AsyncStorage is null. Please run 'npm install @react-native-async-storage/async-storage' or follow the Mixpanel guide to set up your own Storage class."
+          "[Mixpanel] AsyncStorage not available. Install @react-native-async-storage/async-storage (^1.15.0 or ^2.0.0), or provide a custom storage implementation. See: https://github.com/mixpanel/mixpanel-react-native#readme"
         );
-        console.error("[Mixpanel] Falling back to in-memory storage");
+        console.error("[Mixpanel] Falling back to in-memory storage. Data will not persist across app restarts.");
         this.storage = new InMemoryStorage();
       }
     } else {

package/package.json

@@ -1,8 +1,21 @@
 {
   "name": "mixpanel-react-native",
-  "version": "3.2.0-beta.3",
+  "version": "3.2.0",
   "description": "Official React Native Tracking Library for Mixpanel Analytics",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "javascript/",
+    "ios/",
+    "android/src/",
+    "android/build.gradle",
+    "MixpanelReactNative.podspec",
+    "react-native.config.js",
+    "README.md",
+    "LICENSE.md",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "test": "jest"
   },
@@ -31,18 +44,17 @@
     "mp_lib": "react-native"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.3",
-    "@babel/runtime": "^7.12.1",
-    "@react-native-community/eslint-config": "^2.0.0",
-    "babel-jest": "^26.6.0",
-    "eslint": "^7.11.0",
-    "jest": "^26.6.3",
+    "@react-native-async-storage/async-storage": "^1.24.0",
+    "@babel/core": "^7.26.0",
+    "@babel/runtime": "^7.26.0",
+    "@react-native-community/eslint-config": "^3.2.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
     "jest-fetch-mock": "^3.0.3",
-    "jsdoc": "^4.0.5",
-    "metro-react-native-babel-preset": "^0.63.0",
-    "react-native": "^0.63.3",
-    "react-native-dotenv": "^3.4.11",
-    "react-test-renderer": "16.13.1"
+    "metro-react-native-babel-preset": "^0.77.0",
+    "react-native": "^0.76.0",
+    "react-test-renderer": "^18.3.1"
   },
   "jest": {
     "modulePathIgnorePatterns": [
@@ -56,13 +68,21 @@
     ],
     "verbose": true,
     "preset": "react-native",
-    "transform": {
-      "^.+\\.js$": "<rootDir>/node_modules/react-native/jest/preprocessor.js"
-    }
+    "transformIgnorePatterns": [
+      "node_modules/(?!(@react-native|react-native|react-native-get-random-values|uuid)/)"
+    ],
+    "testEnvironment": "node"
   },
   "dependencies": {
-    "@react-native-async-storage/async-storage": "^1.24.0",
     "react-native-get-random-values": "^1.9.0",
-    "uuid": "3.3.2"
+    "uuid": "^9.0.1"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^1.15.0 || ^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
   }
-}
+}

package/.github/dependabot.yml

@@ -1,7 +0,0 @@
-# .github/dependabot.yml
-version: 2
-updates:
-  - package-ecosystem: "npm" # Or "yarn"
-    directory: "/" # Tells Dependabot to scan root directory only
-    schedule:
-      interval: "daily"