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

package/CHANGELOG.md

@@ -1,22 +1,5 @@
 #
 
-## [v3.2.0-beta.3](https://github.com/mixpanel/mixpanel-react-native/tree/v3.2.0-beta.3) (2025-12-15)
-
-### Features
-
-- **Feature Flags**: Enable JavaScript mode support for Feature Flags
-  - Full support for Expo and React Native Web
-  - Runtime context updates via `updateContext()` (JavaScript mode only)
-  - Complete parity with native implementation
-  - Automatic fallback to JavaScript mode when native modules unavailable
-  - AsyncStorage-based caching for offline support
-
-### Improvements
-
-- Remove environment variable requirement for JavaScript mode flags
-- Enhanced documentation with Expo-specific examples
-- Improved test coverage for JavaScript mode
-
 ## [v3.1.3](https://github.com/mixpanel/mixpanel-react-native/tree/v3.1.3) (2025-12-15)
 
 ### Fixes

package/README.md

@@ -47,7 +47,15 @@ Mixpanel's React Native SDK is a wrapper around Mixpanel’s native iOS and Andr
 npm install mixpanel-react-native
 ```
 
-2. Under your application's ios folder, run
+2. Install AsyncStorage (required for data persistence):
+
+```
+npm install @react-native-async-storage/async-storage
+```
+
+> **Note:** Starting from v3.2.0, `@react-native-async-storage/async-storage` is a peer dependency. This allows your project to use either v1.x or v2.x, avoiding conflicts with frameworks like Expo 52+.
+
+3. Under your application's ios folder, run
 
 ```
 pod install
@@ -55,7 +63,7 @@ pod install
 
 Please note: You do not need to update your Podfile to add Mixpanel.
 
-3. Since Xcode 12.5, there is a known swift compile issue, please refer to this **[workaround](https://github.com/mixpanel/mixpanel-react-native/issues/43#issuecomment-829599732)**. However the compile issue has been resolved in Xcode 13.2.1+, there is no extra step required as long as you upgrade to Xcode 13.2.1+.
+4. Since Xcode 12.5, there is a known swift compile issue, please refer to this **[workaround](https://github.com/mixpanel/mixpanel-react-native/issues/43#issuecomment-829599732)**. However the compile issue has been resolved in Xcode 13.2.1+, there is no extra step required as long as you upgrade to Xcode 13.2.1+.
 
 ### 2. Initialize Mixpanel
 
@@ -115,35 +123,6 @@ const SampleApp = () => {
 export default SampleApp;
 ```
 
-### Feature Flags (Beta - 3.2.0-beta.1+)
-
-Control features dynamically and run A/B tests with Mixpanel Feature Flags. **Native mode only** (iOS/Android) in beta.
-
-#### Quick Start
-
-```js
-// Enable during initialization
-await mixpanel.init(false, {}, 'https://api.mixpanel.com', true, {
-  enabled: true,
-  context: { platform: 'mobile' }  // Optional targeting context
-});
-
-// Check if feature is enabled
-if (mixpanel.flags.areFlagsReady()) {
-  const showNewUI = mixpanel.flags.isEnabledSync('new-feature', false);
-  const buttonColor = mixpanel.flags.getVariantValueSync('button-color', 'blue');
-}
-```
-
-#### Key Methods
-
-- `areFlagsReady()` - Check if flags are loaded
-- `isEnabledSync(name, fallback)` - Check if feature is enabled
-- `getVariantValueSync(name, fallback)` - Get variant value
-- `getVariantSync(name, fallback)` - Get full variant object with metadata
-
-All methods support async versions and snake_case aliases. See **[Feature Flags Quick Start Guide](FEATURE_FLAGS_QUICKSTART.md)** for complete documentation.
-
 ### Expo and React Native for Web support (3.0.2 and above)
 
 Starting from version 3.0.2, we have introduced support for Expo, React Native for Web, and other platforms utilizing React Native that do not support iOS and Android directly.

package/android/src/main/java/com/mixpanel/reactnative/MixpanelReactNativeModule.java

@@ -1,9 +1,6 @@
 package com.mixpanel.reactnative;
 
 import com.mixpanel.android.mpmetrics.MixpanelAPI;
-import com.mixpanel.android.mpmetrics.MixpanelOptions;
-import com.mixpanel.android.mpmetrics.MixpanelFlagVariant;
-import com.mixpanel.android.mpmetrics.FlagCompletionCallback;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -12,10 +9,6 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.Dynamic;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeMap;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.Callback;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -40,35 +33,10 @@ public class MixpanelReactNativeModule extends ReactContextBaseJavaModule {
 
 
     @ReactMethod
-    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, boolean useGzipCompression, ReadableMap featureFlagsOptions, Promise promise) throws JSONException {
+    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, boolean useGzipCompression, Promise promise) throws JSONException {
         JSONObject mixpanelProperties = ReactNativeHelper.reactToJSON(metadata);
         AutomaticProperties.setAutomaticProperties(mixpanelProperties);
-
-        // Handle feature flags options
-        boolean featureFlagsEnabled = false;
-        JSONObject featureFlagsContext = null;
-
-        if (featureFlagsOptions != null && featureFlagsOptions.hasKey("enabled")) {
-            featureFlagsEnabled = featureFlagsOptions.getBoolean("enabled");
-
-            if (featureFlagsOptions.hasKey("context")) {
-                featureFlagsContext = ReactNativeHelper.reactToJSON(featureFlagsOptions.getMap("context"));
-            }
-        }
-
-        // Create Mixpanel instance with feature flags configuration
-        MixpanelOptions.Builder optionsBuilder = new MixpanelOptions.Builder()
-            .optOutTrackingDefault(optOutTrackingDefault)
-            .superProperties(mixpanelProperties)
-            .featureFlagsEnabled(featureFlagsEnabled);
-
-        if (featureFlagsContext != null) {
-            optionsBuilder.featureFlagsContext(featureFlagsContext);
-        }
-
-        MixpanelOptions options = optionsBuilder.build();
-
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, trackAutomaticEvents, options);
+        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, optOutTrackingDefault, mixpanelProperties, null, trackAutomaticEvents);
         instance.setServerURL(serverURL);
         if (useGzipCompression) {
             instance.setShouldGzipRequestPayload(true);
@@ -634,242 +602,4 @@ public class MixpanelReactNativeModule extends ReactContextBaseJavaModule {
             promise.resolve(null);
         }
     }
-
-    // Feature Flags Methods
-
-    @ReactMethod
-    public void loadFlags(final String token, Promise promise) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            promise.reject("Instance Error", "Failed to get Mixpanel instance");
-            return;
-        }
-        synchronized (instance) {
-            instance.getFlags().loadFlags();
-            promise.resolve(null);
-        }
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    public boolean areFlagsReadySync(final String token) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            return false;
-        }
-        synchronized (instance) {
-            return instance.getFlags().areFlagsReady();
-        }
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    public WritableMap getVariantSync(final String token, String featureName, ReadableMap fallback) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            return convertVariantToMap(fallback);
-        }
-
-        synchronized (instance) {
-            MixpanelFlagVariant fallbackVariant = convertMapToVariant(fallback);
-            MixpanelFlagVariant variant = instance.getFlags().getVariantSync(featureName, fallbackVariant);
-            return convertVariantToWritableMap(variant);
-        }
-    }
-
-    // Note: For getVariantValueSync, we'll return the full variant and extract value in JS
-    // React Native doesn't support returning Dynamic types from synchronous methods
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    public WritableMap getVariantValueSync(final String token, String featureName, Dynamic fallbackValue) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-
-        WritableMap result = new WritableNativeMap();
-        if (instance == null) {
-            result.putString("type", "fallback");
-            // We'll handle the conversion in JavaScript
-            return result;
-        }
-
-        synchronized (instance) {
-            Object value = instance.getFlags().getVariantValueSync(featureName, ReactNativeHelper.dynamicToObject(fallbackValue));
-            result.putString("type", "value");
-
-            // Convert value to appropriate type
-            if (value == null) {
-                result.putNull("value");
-            } else if (value instanceof String) {
-                result.putString("value", (String) value);
-            } else if (value instanceof Boolean) {
-                result.putBoolean("value", (Boolean) value);
-            } else if (value instanceof Integer) {
-                result.putInt("value", (Integer) value);
-            } else if (value instanceof Double) {
-                result.putDouble("value", (Double) value);
-            } else if (value instanceof Float) {
-                result.putDouble("value", ((Float) value).doubleValue());
-            } else if (value instanceof Long) {
-                result.putDouble("value", ((Long) value).doubleValue());
-            } else {
-                result.putString("value", value.toString());
-            }
-
-            return result;
-        }
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    public boolean isEnabledSync(final String token, String featureName, boolean fallbackValue) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            return fallbackValue;
-        }
-
-        synchronized (instance) {
-            return instance.getFlags().isEnabledSync(featureName, fallbackValue);
-        }
-    }
-
-    @ReactMethod
-    public void getVariant(final String token, String featureName, ReadableMap fallback, final Promise promise) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            promise.resolve(convertVariantToMap(fallback));
-            return;
-        }
-
-        synchronized (instance) {
-            MixpanelFlagVariant fallbackVariant = convertMapToVariant(fallback);
-            instance.getFlags().getVariant(featureName, fallbackVariant, new FlagCompletionCallback<MixpanelFlagVariant>() {
-                @Override
-                public void onComplete(MixpanelFlagVariant variant) {
-                    promise.resolve(convertVariantToWritableMap(variant));
-                }
-            });
-        }
-    }
-
-    @ReactMethod
-    public void getVariantValue(final String token, String featureName, Dynamic fallbackValue, final Promise promise) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            promise.resolve(fallbackValue);
-            return;
-        }
-
-        synchronized (instance) {
-            Object fallbackObj = ReactNativeHelper.dynamicToObject(fallbackValue);
-            instance.getFlags().getVariantValue(featureName, fallbackObj, new FlagCompletionCallback<Object>() {
-                @Override
-                public void onComplete(Object value) {
-                    // Convert the value back to a format React Native can handle
-                    if (value == null) {
-                        promise.resolve(null);
-                    } else if (value instanceof String) {
-                        promise.resolve((String) value);
-                    } else if (value instanceof Boolean) {
-                        promise.resolve((Boolean) value);
-                    } else if (value instanceof Number) {
-                        promise.resolve(((Number) value).doubleValue());
-                    } else if (value instanceof JSONObject) {
-                        try {
-                            WritableMap map = ReactNativeHelper.convertJsonToMap((JSONObject) value);
-                            promise.resolve(map);
-                        } catch (Exception e) {
-                            promise.resolve(value.toString());
-                        }
-                    } else if (value instanceof JSONArray) {
-                        try {
-                            WritableArray array = ReactNativeHelper.convertJsonToArray((JSONArray) value);
-                            promise.resolve(array);
-                        } catch (Exception e) {
-                            promise.resolve(value.toString());
-                        }
-                    } else {
-                        promise.resolve(value.toString());
-                    }
-                }
-            });
-        }
-    }
-
-    @ReactMethod
-    public void isEnabled(final String token, String featureName, boolean fallbackValue, final Promise promise) {
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, true);
-        if (instance == null) {
-            promise.resolve(fallbackValue);
-            return;
-        }
-
-        synchronized (instance) {
-            instance.getFlags().isEnabled(featureName, fallbackValue, new FlagCompletionCallback<Boolean>() {
-                @Override
-                public void onComplete(Boolean isEnabled) {
-                    promise.resolve(isEnabled);
-                }
-            });
-        }
-    }
-
-    // Helper methods for variant conversion
-    private MixpanelFlagVariant convertMapToVariant(ReadableMap map) {
-        if (map == null) {
-            return new MixpanelFlagVariant("", null);
-        }
-
-        String key = map.hasKey("key") ? map.getString("key") : "";
-        Object value = map.hasKey("value") ? ReactNativeHelper.dynamicToObject(map.getDynamic("value")) : null;
-        String experimentID = map.hasKey("experimentID") ? map.getString("experimentID") : null;
-        Boolean isExperimentActive = map.hasKey("isExperimentActive") ? map.getBoolean("isExperimentActive") : null;
-        Boolean isQATester = map.hasKey("isQATester") ? map.getBoolean("isQATester") : null;
-
-        // Create variant with all properties using the full constructor
-        return new MixpanelFlagVariant(key, value, experimentID, isExperimentActive, isQATester);
-    }
-
-    private WritableMap convertVariantToMap(ReadableMap source) {
-        WritableMap map = new WritableNativeMap();
-        if (source != null) {
-            map.merge(source);
-        }
-        return map;
-    }
-
-    private WritableMap convertVariantToWritableMap(MixpanelFlagVariant variant) {
-        WritableMap map = new WritableNativeMap();
-
-        if (variant != null) {
-            map.putString("key", variant.key);
-
-            Object value = variant.value;
-            if (value == null) {
-                map.putNull("value");
-            } else if (value instanceof String) {
-                map.putString("value", (String) value);
-            } else if (value instanceof Boolean) {
-                map.putBoolean("value", (Boolean) value);
-            } else if (value instanceof Integer) {
-                map.putInt("value", (Integer) value);
-            } else if (value instanceof Double) {
-                map.putDouble("value", (Double) value);
-            } else if (value instanceof Float) {
-                map.putDouble("value", ((Float) value).doubleValue());
-            } else if (value instanceof Long) {
-                map.putDouble("value", ((Long) value).doubleValue());
-            } else {
-                // For complex objects, convert to string
-                map.putString("value", value.toString());
-            }
-
-            // Add optional fields if they exist
-            if (variant.experimentID != null) {
-                map.putString("experimentID", variant.experimentID);
-            }
-            if (variant.isExperimentActive != null) {
-                map.putBoolean("isExperimentActive", variant.isExperimentActive);
-            }
-            if (variant.isQATester != null) {
-                map.putBoolean("isQATester", variant.isQATester);
-            }
-        }
-
-        return map;
-    }
 }

package/index.d.ts

@@ -7,69 +7,7 @@ export type MixpanelAsyncStorage = {
   removeItem(key: string): Promise<void>;
 };
 
-export interface MixpanelFlagVariant {
-  key: string;
-  value: any;
-  experiment_id?: string | number;  // Updated to match mixpanel-js format
-  is_experiment_active?: boolean;    // Updated to match mixpanel-js format
-  is_qa_tester?: boolean;            // Updated to match mixpanel-js format
-}
-
-export interface FeatureFlagsOptions {
-  enabled?: boolean;
-  context?: {
-    [key: string]: any;
-    custom_properties?: {
-      [key: string]: any;
-    };
-  };
-}
-
-export interface UpdateContextOptions {
-  replace?: boolean;
-}
-
-export interface Flags {
-  // Synchronous methods
-  loadFlags(): Promise<void>;
-  areFlagsReady(): boolean;
-  getVariantSync(featureName: string, fallback: MixpanelFlagVariant): MixpanelFlagVariant;
-  getVariantValueSync(featureName: string, fallbackValue: any): any;
-  isEnabledSync(featureName: string, fallbackValue?: boolean): boolean;
-
-  // Asynchronous methods with overloads for callback and Promise patterns
-  getVariant(featureName: string, fallback: MixpanelFlagVariant): Promise<MixpanelFlagVariant>;
-  getVariant(featureName: string, fallback: MixpanelFlagVariant, callback: (result: MixpanelFlagVariant) => void): void;
-
-  getVariantValue(featureName: string, fallbackValue: any): Promise<any>;
-  getVariantValue(featureName: string, fallbackValue: any, callback: (value: any) => void): void;
-
-  isEnabled(featureName: string, fallbackValue?: boolean): Promise<boolean>;
-  isEnabled(featureName: string, fallbackValue: boolean, callback: (isEnabled: boolean) => void): void;
-
-  // Context management (NEW - aligned with mixpanel-js)
-  // NOTE: Only available in JavaScript mode (Expo/React Native Web)
-  // In native mode, throws an error - context must be set during initialization
-  updateContext(newContext: MixpanelProperties, options?: UpdateContextOptions): Promise<void>;
-
-  // snake_case aliases (NEW - aligned with mixpanel-js)
-  are_flags_ready(): boolean;
-  get_variant(featureName: string, fallback: MixpanelFlagVariant): Promise<MixpanelFlagVariant>;
-  get_variant(featureName: string, fallback: MixpanelFlagVariant, callback: (result: MixpanelFlagVariant) => void): void;
-  get_variant_sync(featureName: string, fallback: MixpanelFlagVariant): MixpanelFlagVariant;
-  get_variant_value(featureName: string, fallbackValue: any): Promise<any>;
-  get_variant_value(featureName: string, fallbackValue: any, callback: (value: any) => void): void;
-  get_variant_value_sync(featureName: string, fallbackValue: any): any;
-  is_enabled(featureName: string, fallbackValue?: boolean): Promise<boolean>;
-  is_enabled(featureName: string, fallbackValue: boolean, callback: (isEnabled: boolean) => void): void;
-  is_enabled_sync(featureName: string, fallbackValue?: boolean): boolean;
-  // NOTE: Only available in JavaScript mode (Expo/React Native Web)
-  update_context(newContext: MixpanelProperties, options?: UpdateContextOptions): Promise<void>;
-}
-
 export class Mixpanel {
-  readonly flags: Flags;
-
   constructor(token: string, trackAutoMaticEvents: boolean);
   constructor(token: string, trackAutoMaticEvents: boolean, useNative: true);
   constructor(
@@ -87,8 +25,7 @@ export class Mixpanel {
     optOutTrackingDefault?: boolean,
     superProperties?: MixpanelProperties,
     serverURL?: string,
-    useGzipCompression?: boolean,
-    featureFlagsOptions?: FeatureFlagsOptions
+    useGzipCompression?: boolean
   ): Promise<void>;
   setServerURL(serverURL: string): void;
   setLoggingEnabled(loggingEnabled: boolean): void;

package/index.js

@@ -4,7 +4,6 @@ import {Platform, NativeModules} from "react-native";
 import packageJson from "./package.json";
 const {MixpanelReactNative} = NativeModules;
 import MixpanelMain from "mixpanel-react-native/javascript/mixpanel-main"
-import { MixpanelLogger } from "mixpanel-react-native/javascript/mixpanel-logger"
 
 const DevicePlatform = {
   Unknown: "Unknown",
@@ -47,8 +46,6 @@ export class Mixpanel {
     }
     this.token = token;
     this.trackAutomaticEvents = trackAutomaticEvents;
-    this._flags = null; // Lazy-loaded flags instance
-    this.storage = storage; // Store for JavaScript mode
 
     if (useNative && MixpanelReactNative) {
       this.mixpanelImpl = MixpanelReactNative;
@@ -63,117 +60,27 @@ export class Mixpanel {
   }
 
   /**
-   * Returns the Flags instance for feature flags operations.
+   * Initializes Mixpanel
    *
-   * <p>Feature Flags enable dynamic feature control and A/B testing capabilities.
-   * This property is lazy-loaded to avoid unnecessary initialization until first access.
-   *
-   * <p><b>Native Mode Only:</b> Feature flags are currently only available when using native mode
-   * (iOS/Android). JavaScript mode (Expo/React Native Web) support is planned for a future release.
-   *
-   * @return {Flags} an instance of Flags that provides access to feature flag operations
-   * @throws {Error} if accessed in JavaScript mode (when native modules are not available)
-   *
-   * @example
-   * // Check if flags are ready
-   * if (mixpanel.flags.areFlagsReady()) {
-   *   const isEnabled = mixpanel.flags.isEnabledSync('new-checkout', false);
-   * }
-   *
-   * @example
-   * // Get a feature variant value
-   * const buttonColor = mixpanel.flags.getVariantValueSync('button-color', 'blue');
-   *
-   * @see Flags
-   */
-  get flags() {
-    if (!this._flags) {
-      // Check if feature flags are enabled and warn if not
-      if (!this.featureFlagsOptions || !this.featureFlagsOptions.enabled) {
-        MixpanelLogger.warn(
-          this.token,
-          "Accessing feature flags API but flags are not enabled. " +
-          "Call init() with featureFlagsOptions.enabled = true to enable feature flags. " +
-          "Flag methods will return fallback values."
-        );
-      }
-      // Lazy load the Flags instance with proper dependencies
-      const Flags = require("./javascript/mixpanel-flags").Flags;
-      this._flags = new Flags(this.token, this.mixpanelImpl, this.storage);
-    }
-    return this._flags;
-  }
-
-  /**
-   * Initializes Mixpanel with optional configuration for tracking, super properties, and feature flags.
-   *
-   * <p>This method must be called before using any other Mixpanel functionality. It sets up
-   * the tracking environment, registers super properties, and optionally initializes feature flags.
-   *
-   * @param {boolean} [optOutTrackingDefault=false] Whether or not Mixpanel can start tracking by default.
-   *     If true, no data will be tracked until optInTracking() is called. See optOutTracking()
-   * @param {object} [superProperties={}] A Map containing the key value pairs of the super properties to register.
-   *     These properties will be sent with every event. Pass {} if no super properties needed.
-   * @param {string} [serverURL="https://api.mixpanel.com"] The base URL used for Mixpanel API requests.
-   *     Use "https://api-eu.mixpanel.com" for EU data residency. See setServerURL()
-   * @param {boolean} [useGzipCompression=false] Whether to use gzip compression for network requests.
-   *     Enabling this reduces bandwidth usage but adds slight CPU overhead.
-   * @param {object} [featureFlagsOptions={}] Feature flags configuration object with the following properties:
-   * @param {boolean} [featureFlagsOptions.enabled=false] Whether to enable feature flags functionality
-   * @param {object} [featureFlagsOptions.context={}] Context properties used for feature flag targeting.
-   *     Can include user properties, device properties, or any custom properties for flag evaluation.
-   *     Note: In native mode, context must be set during initialization and cannot be updated later.
-   * @returns {Promise<void>} A promise that resolves when initialization is complete
-   *
-   * @example
-   * // Basic initialization
-   * const mixpanel = new Mixpanel('YOUR_TOKEN', true);
-   * await mixpanel.init();
-   *
-   * @example
-   * // Initialize with feature flags enabled
-   * const mixpanel = new Mixpanel('YOUR_TOKEN', true);
-   * await mixpanel.init(false, {}, 'https://api.mixpanel.com', false, {
-   *   enabled: true,
-   *   context: {
-   *     platform: 'mobile',
-   *     app_version: '2.1.0'
-   *   }
-   * });
-   *
-   * @example
-   * // Initialize with EU data residency and super properties
-   * await mixpanel.init(
-   *   false,
-   *   { plan: 'premium', region: 'eu' },
-   *   'https://api-eu.mixpanel.com',
-   *   true
-   * );
+   * @param {boolean} optOutTrackingDefault Optional Whether or not Mixpanel can start tracking by default. See optOutTracking()
+   * @param {object} superProperties  Optional A Map containing the key value pairs of the super properties to register
+   * @param {string} serverURL Optional Set the base URL used for Mixpanel API requests. See setServerURL()
+   * @param {boolean} useGzipCompression Optional Set whether to use gzip compression for network requests. Defaults to false.
    */
   async init(
     optOutTrackingDefault = DEFAULT_OPT_OUT,
     superProperties = {},
     serverURL = "https://api.mixpanel.com",
-    useGzipCompression = false,
-    featureFlagsOptions = {}
+    useGzipCompression = false
   ) {
-    // Store feature flags options for later use
-    this.featureFlagsOptions = featureFlagsOptions;
-
     await this.mixpanelImpl.initialize(
       this.token,
       this.trackAutomaticEvents,
       optOutTrackingDefault,
       {...Helper.getMetaData(), ...superProperties},
       serverURL,
-      useGzipCompression,
-      featureFlagsOptions
+      useGzipCompression
     );
-
-    // If flags are enabled AND we're in native mode, initialize them
-    if (featureFlagsOptions.enabled && this.mixpanelImpl === MixpanelReactNative) {
-      await this.flags.loadFlags();
-  }
   }
 
   /**
@@ -202,9 +109,7 @@ export class Mixpanel {
       trackAutomaticEvents,
       optOutTrackingDefault,
       Helper.getMetaData(),
-      "https://api.mixpanel.com",
-      false,
-      {}
+      "https://api.mixpanel.com"
     );
     return new Mixpanel(token, trackAutomaticEvents);
   }

package/ios/MixpanelReactNative.m

@@ -5,7 +5,7 @@
 
 // MARK: - Mixpanel Instance
 
-RCT_EXTERN_METHOD(initialize:(NSString *)token trackAutomaticEvents:(BOOL)trackAutomaticEvents optOutTrackingByDefault:(BOOL)optOutTrackingByDefault properties:(NSDictionary *)properties serverURL:(NSString *)serverURL useGzipCompression:(BOOL)useGzipCompression featureFlagsOptions:(NSDictionary *)featureFlagsOptions resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(initialize:(NSString *)token trackAutomaticEvents:(BOOL)trackAutomaticEvents optOutTrackingByDefault:(BOOL)optOutTrackingByDefault properties:(NSDictionary *)properties serverURL:(NSString *)serverURL useGzipCompression:(BOOL)useGzipCompression resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 // Mark: - Settings
 RCT_EXTERN_METHOD(setServerURL:(NSString *)token serverURL:(NSString *)serverURL resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
@@ -105,22 +105,4 @@ RCT_EXTERN_METHOD(groupRemovePropertyValue:(NSString *)token groupKey:(NSString
 
 RCT_EXTERN_METHOD(groupUnionProperty:(NSString *)token groupKey:(NSString *)groupKey groupID:(id)groupID name:(NSString *)name values:(NSArray *)values resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
-// MARK: - Feature Flags
-
-RCT_EXTERN_METHOD(loadFlags:(NSString *)token resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(areFlagsReadySync:(NSString *)token)
-
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getVariantSync:(NSString *)token featureName:(NSString *)featureName fallback:(NSDictionary *)fallback)
-
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getVariantValueSync:(NSString *)token featureName:(NSString *)featureName fallbackValue:(id)fallbackValue)
-
-RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(isEnabledSync:(NSString *)token featureName:(NSString *)featureName fallbackValue:(BOOL)fallbackValue)
-
-RCT_EXTERN_METHOD(getVariant:(NSString *)token featureName:(NSString *)featureName fallback:(NSDictionary *)fallback resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(getVariantValue:(NSString *)token featureName:(NSString *)featureName fallbackValue:(id)fallbackValue resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(isEnabled:(NSString *)token featureName:(NSString *)featureName fallbackValue:(BOOL)fallbackValue resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-
 @end