mixpanel-react-native 3.1.2 → 3.2.0-beta.0

package/__tests__/index.test.js

@@ -8,7 +8,9 @@ test(`it calls MixpanelReactNative initialize`, async () => {
     true,
     false,
     { $lib_version: expect.any(String), mp_lib: "react-native" },
-    "https://api.mixpanel.com"
+    "https://api.mixpanel.com",
+    false,
+    {}
   );
 });
 
@@ -25,7 +27,8 @@ test(`it calls MixpanelReactNative initialize with optOut, superProperties and u
       super: "property",
     },
     "https://api.mixpanel.com",
-    false
+    false,
+    {}
   );
 });
 
@@ -41,7 +44,8 @@ test(`it passes useGzipCompression parameter to native modules when enabled`, as
       mp_lib: "react-native",
     },
     "https://api.mixpanel.com",
-    true
+    true,
+    {}
   );
 });
 

package/__tests__/jest_setup.js

@@ -21,9 +21,16 @@ jest.mock("uuid", () => ({
 }));
 
 jest.mock("@react-native-async-storage/async-storage", () => ({
+  default: {
+    getItem: jest.fn().mockResolvedValue(null),
+    setItem: jest.fn().mockResolvedValue(undefined),
+    removeItem: jest.fn().mockResolvedValue(undefined),
+    clear: jest.fn().mockResolvedValue(undefined),
+  },
   getItem: jest.fn().mockResolvedValue(null),
   setItem: jest.fn().mockResolvedValue(undefined),
   removeItem: jest.fn().mockResolvedValue(undefined),
+  clear: jest.fn().mockResolvedValue(undefined),
 }));
 
 jest.doMock("react-native", () => {
@@ -85,6 +92,17 @@ jest.doMock("react-native", () => {
           groupUnsetProperty: jest.fn(),
           groupRemovePropertyValue: jest.fn(),
           groupUnionProperty: jest.fn(),
+          // Feature Flags native module mocks
+          loadFlags: jest.fn().mockResolvedValue(true),
+          areFlagsReadySync: jest.fn().mockReturnValue(false),
+          getVariantSync: jest.fn(),
+          getVariantValueSync: jest.fn(),
+          isEnabledSync: jest.fn(),
+          getVariant: jest.fn().mockResolvedValue({ key: 'control', value: 'default' }),
+          getVariantValue: jest.fn().mockResolvedValue('default'),
+          isEnabled: jest.fn().mockResolvedValue(false),
+          updateContext: jest.fn().mockResolvedValue(undefined),  // Added for mixpanel-js alignment
+          updateFlagsContext: jest.fn().mockResolvedValue(true),
         },
       },
     },

package/android/build.gradle

@@ -41,5 +41,5 @@ repositories {
 
 dependencies {
     implementation 'com.facebook.react:react-native:+'
-    implementation 'com.mixpanel.android:mixpanel-android:8.2.0'
+    implementation 'com.mixpanel.android:mixpanel-android:8.2.4'
 }

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

@@ -1,6 +1,9 @@
 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;
@@ -9,6 +12,10 @@ 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;
@@ -33,10 +40,35 @@ public class MixpanelReactNativeModule extends ReactContextBaseJavaModule {
 
 
     @ReactMethod
-    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, boolean useGzipCompression, Promise promise) throws JSONException {
+    public void initialize(String token, boolean trackAutomaticEvents, boolean optOutTrackingDefault, ReadableMap metadata, String serverURL, boolean useGzipCompression, ReadableMap featureFlagsOptions, Promise promise) throws JSONException {
         JSONObject mixpanelProperties = ReactNativeHelper.reactToJSON(metadata);
         AutomaticProperties.setAutomaticProperties(mixpanelProperties);
-        MixpanelAPI instance = MixpanelAPI.getInstance(this.mReactContext, token, optOutTrackingDefault, mixpanelProperties, null, trackAutomaticEvents);
+
+        // 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);
         instance.setServerURL(serverURL);
         if (useGzipCompression) {
             instance.setShouldGzipRequestPayload(true);
@@ -602,4 +634,242 @@ 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,7 +7,69 @@ 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(
@@ -25,7 +87,8 @@ export class Mixpanel {
     optOutTrackingDefault?: boolean,
     superProperties?: MixpanelProperties,
     serverURL?: string,
-    useGzipCompression?: boolean
+    useGzipCompression?: boolean,
+    featureFlagsOptions?: FeatureFlagsOptions
   ): Promise<void>;
   setServerURL(serverURL: string): void;
   setLoggingEnabled(loggingEnabled: boolean): void;

package/index.js

@@ -46,6 +46,8 @@ 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;
@@ -59,6 +61,30 @@ export class Mixpanel {
     this.mixpanelImpl = new MixpanelMain(token, trackAutomaticEvents, storage);
   }
 
+  /**
+   * Returns the Flags instance for feature flags operations.
+   * This property is lazy-loaded to avoid unnecessary initialization.
+   *
+   * NOTE: Feature flags are only available in native mode.
+   * JavaScript mode is not yet supported.
+   */
+  get flags() {
+    // Short circuit for JavaScript mode - flags not ready for public use
+    if (this.mixpanelImpl !== MixpanelReactNative) {
+      throw new Error(
+        "Feature flags are only available in native mode. " +
+        "JavaScript mode support is coming in a future release."
+      );
+    }
+
+    if (!this._flags) {
+      // 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
    *
@@ -66,21 +92,32 @@ export class Mixpanel {
    * @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.
+   * @param {object} featureFlagsOptions Optional Feature flags configuration including enabled flag and context
    */
   async init(
     optOutTrackingDefault = DEFAULT_OPT_OUT,
     superProperties = {},
     serverURL = "https://api.mixpanel.com",
-    useGzipCompression = false
+    useGzipCompression = false,
+    featureFlagsOptions = {}
   ) {
+    // Store feature flags options for later use
+    this.featureFlagsOptions = featureFlagsOptions;
+
     await this.mixpanelImpl.initialize(
       this.token,
       this.trackAutomaticEvents,
       optOutTrackingDefault,
       {...Helper.getMetaData(), ...superProperties},
       serverURL,
-      useGzipCompression
+      useGzipCompression,
+      featureFlagsOptions
     );
+
+    // If flags are enabled AND we're in native mode, initialize them
+    if (featureFlagsOptions.enabled && this.mixpanelImpl === MixpanelReactNative) {
+      await this.flags.loadFlags();
+  }
   }
 
   /**
@@ -109,7 +146,9 @@ export class Mixpanel {
       trackAutomaticEvents,
       optOutTrackingDefault,
       Helper.getMetaData(),
-      "https://api.mixpanel.com"
+      "https://api.mixpanel.com",
+      false,
+      {}
     );
     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 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 featureFlagsOptions:(NSDictionary *)featureFlagsOptions resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 
 // Mark: - Settings
 RCT_EXTERN_METHOD(setServerURL:(NSString *)token serverURL:(NSString *)serverURL resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
@@ -105,4 +105,22 @@ 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