react-native-insider 7.0.11 → 7.0.12

package/RNInsider.podspec

@@ -9,12 +9,12 @@ Pod::Spec.new do |s|
   s.authors      = package_json['author']
   s.license      = 'MIT'
   s.platform     = :ios, '12.0'
-  s.source = {:http => 'https://mobilesdk.useinsider.com/iOS/14.2.7/InsiderMobileIOSFramework.zip'}
+  s.source = {:http => 'https://mobilesdk.useinsider.com/iOS/14.2.8/InsiderMobileIOSFramework.zip'}
   s.source_files = 'ios/RNInsider/*.{h,m}'
   s.requires_arc = true
   s.static_framework = true
   s.dependency 'React'
-  s.dependency 'InsiderMobile', '14.2.7'
+  s.dependency 'InsiderMobile', '14.2.8'
   s.dependency 'InsiderGeofence', '1.2.4'
   s.dependency 'InsiderHybrid', '1.7.6'
 end

package/android/build.gradle

@@ -42,7 +42,7 @@ repositories {
 
 dependencies {
     implementation "com.facebook.react:react-native:${getVersionFromPartner('reactNativeVersion', '+')}"
-    implementation 'com.useinsider:insider:15.2.5'
+    implementation 'com.useinsider:insider:15.2.6'
     implementation 'com.useinsider:insiderhybrid:1.3.4'
 
     implementation 'androidx.security:security-crypto:1.1.0-alpha06'

package/android/src/main/java/com/useinsider/react/RNInsiderModule.java

@@ -22,6 +22,7 @@ import com.useinsider.insider.InsiderCallbackType;
 import com.useinsider.insider.InsiderIdentifiers;
 import com.useinsider.insider.InsiderUser;
 import com.useinsider.insider.InsiderProduct;
+import com.useinsider.insider.CloseButtonPosition;
 import com.useinsider.insider.MessageCenterData;
 import com.useinsider.insider.RecommendationEngine;
 import com.useinsider.insiderhybrid.InsiderHybrid;
@@ -465,66 +466,108 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void itemPurchased(String saleID, ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
+    public void itemPurchased(String saleID, ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters, ReadableArray eventCustomParameters) {
         try {
             InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
-            Insider.Instance.itemPurchased(saleID, product);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(eventCustomParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.itemPurchased(saleID, product, mappedCustomParameters);
+            } else {
+                Insider.Instance.itemPurchased(saleID, product);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void itemAddedToCart(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
+    public void itemAddedToCart(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters, ReadableArray eventCustomParameters) {
         try {
             InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
-            Insider.Instance.itemAddedToCart(product);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(eventCustomParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.itemAddedToCart(product, mappedCustomParameters);
+            } else {
+                Insider.Instance.itemAddedToCart(product);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void itemRemovedFromCart(String productID) {
+    public void itemRemovedFromCart(String productID, ReadableArray customParameters) {
         try {
-            Insider.Instance.itemRemovedFromCart(productID);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.itemRemovedFromCart(productID, mappedCustomParameters);
+            } else {
+                Insider.Instance.itemRemovedFromCart(productID);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void cartCleared() {
+    public void cartCleared(ReadableArray customParameters) {
         try {
-            Insider.Instance.cartCleared();
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.cartCleared(mappedCustomParameters);
+            } else {
+                Insider.Instance.cartCleared();
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void itemAddedToWishlist(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
+    public void itemAddedToWishlist(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters, ReadableArray eventCustomParameters) {
         try {
             InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
-            Insider.Instance.itemAddedToWishlist(product);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(eventCustomParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.itemAddedToWishlist(product, mappedCustomParameters);
+            } else {
+                Insider.Instance.itemAddedToWishlist(product);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void itemRemovedFromWishlist(String productID) {
+    public void itemRemovedFromWishlist(String productID, ReadableArray customParameters) {
         try {
-            Insider.Instance.itemRemovedFromWishlist(productID);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.itemRemovedFromWishlist(productID, mappedCustomParameters);
+            } else {
+                Insider.Instance.itemRemovedFromWishlist(productID);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void wishlistCleared() {
+    public void wishlistCleared(ReadableArray customParameters) {
         try {
-            Insider.Instance.wishlistCleared();
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.wishlistCleared(mappedCustomParameters);
+            } else {
+                Insider.Instance.wishlistCleared();
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -686,65 +729,97 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
 
     @ReactMethod
-    public void visitHomePage() {
+    public void visitHomePage(ReadableArray customParameters) {
         try {
-            Insider.Instance.visitHomePage();
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.visitHomePage(mappedCustomParameters);
+            } else {
+                Insider.Instance.visitHomePage();
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void visitListingPage(ReadableArray taxonomy) {
+    public void visitListingPage(ReadableArray taxonomy, ReadableArray customParameters) {
         try {
             String[] taxonomies = RNUtils.convertReadableArrayToStringArray(taxonomy);
-            Insider.Instance.visitListingPage(taxonomies);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.visitListingPage(taxonomies, mappedCustomParameters);
+            } else {
+                Insider.Instance.visitListingPage(taxonomies);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void visitProductDetailPage(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
+    public void visitProductDetailPage(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters, ReadableArray eventCustomParameters) {
         try {
             InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
-            Insider.Instance.visitProductDetailPage(product);
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(eventCustomParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.visitProductDetailPage(product, mappedCustomParameters);
+            } else {
+                Insider.Instance.visitProductDetailPage(product);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void visitCartPage(ReadableArray products) {
+    public void visitCartPage(ReadableArray products, ReadableArray customParameters) {
         try {
             InsiderProduct[] ips = new InsiderProduct[products.size()];
             for (int i = 0; i < products.size(); i++) {
                 ReadableMap productMap = products.getMap(i);
                 ReadableMap requiredFields = productMap.getMap("requiredFields");
                 ReadableMap optionalFields = productMap.getMap("optionalFields");
-                ReadableArray customParameters = productMap.getArray("customParameters");
-                InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
+                ReadableArray productCustomParameters = productMap.getArray("customParameters");
+                InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, productCustomParameters);
                 ips[i] = product;
             }
-            Insider.Instance.visitCartPage(ips);
+
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.visitCartPage(ips, mappedCustomParameters);
+            } else {
+                Insider.Instance.visitCartPage(ips);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
     @ReactMethod
-    public void visitWishlistPage(ReadableArray products) {
+    public void visitWishlistPage(ReadableArray products, ReadableArray customParameters) {
         try {
             InsiderProduct[] ips = new InsiderProduct[products.size()];
             for (int i = 0; i < products.size(); i++) {
                 ReadableMap productMap = products.getMap(i);
                 ReadableMap requiredFields = productMap.getMap("requiredFields");
                 ReadableMap optionalFields = productMap.getMap("optionalFields");
-                ReadableArray customParameters = productMap.getArray("customParameters");
-                InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
+                ReadableArray productCustomParameters = productMap.getArray("customParameters");
+                InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, productCustomParameters);
                 ips[i] = product;
             }
-            Insider.Instance.visitWishlistPage(ips);
+
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.visitWishlistPage(ips, mappedCustomParameters);
+            } else {
+                Insider.Instance.visitWishlistPage(ips);
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -880,9 +955,26 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void signUpConfirmation() {
+    public void signUpConfirmation(ReadableArray customParameters) {
+        try {
+            Map<String, Object> mappedCustomParameters = RNUtils.parseCustomParameters(customParameters);
+
+            if (!mappedCustomParameters.isEmpty()) {
+                Insider.Instance.signUpConfirmation(mappedCustomParameters);
+            } else {
+                Insider.Instance.signUpConfirmation();
+            }
+        } catch (Exception e) {
+            Insider.Instance.putException(e);
+        }
+    }
+
+    @ReactMethod
+    public void setInternalBrowserCloseButtonPosition(String position) {
         try {
-            Insider.Instance.signUpConfirmation();
+            if (position == null) return;
+            CloseButtonPosition enumPosition = CloseButtonPosition.valueOf(position);
+            Insider.Instance.setInternalBrowserCloseButtonPosition(enumPosition);
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }

package/android/src/main/java/com/useinsider/react/RNUtils.java

@@ -379,4 +379,73 @@ public class RNUtils {
 
         return product;
     }
+
+    public static Map<String, Object> parseCustomParameters(ReadableArray customParameters) {
+        Map<String, Object> mappedCustomParameters = new HashMap<>();
+        try {
+            if (customParameters == null) {
+                return mappedCustomParameters;
+            }
+
+            for (int i = 0; i < customParameters.size(); i++) {
+                ReadableMap parameter = customParameters.getMap(i);
+                if (parameter == null) continue;
+
+                String type = parameter.hasKey("type") ? parameter.getString("type") : null;
+                String key = parameter.hasKey("key") ? parameter.getString("key") : null;
+                if (type == null || key == null) continue;
+
+                switch (type) {
+                    case "string":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            mappedCustomParameters.put(key, parameter.getString("value"));
+                        }
+                        break;
+                    case "integer":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            mappedCustomParameters.put(key, parameter.getInt("value"));
+                        }
+                        break;
+                    case "double":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            mappedCustomParameters.put(key, parameter.getDouble("value"));
+                        }
+                        break;
+                    case "boolean":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            mappedCustomParameters.put(key, parameter.getBoolean("value"));
+                        }
+                        break;
+                    case "date":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            double epochMillis = parameter.getDouble("value");
+                            Date dateValue = new Date((long) epochMillis);
+                            mappedCustomParameters.put(key, dateValue);
+                        }
+                        break;
+                    case "numeric_array":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            ReadableArray arrayValue = parameter.getArray("value");
+                            Number[] numberArray = convertReadableArrayToNumericArray(arrayValue);
+                            if (numberArray != null) {
+                                mappedCustomParameters.put(key, numberArray);
+                            }
+                        }
+                        break;
+                    case "string_array":
+                        if (parameter.hasKey("value") && !parameter.isNull("value")) {
+                            ReadableArray arrayValue = parameter.getArray("value");
+                            String[] stringArray = convertReadableArrayToStringArray(arrayValue);
+                            if (stringArray != null) {
+                                mappedCustomParameters.put(key, stringArray);
+                            }
+                        }
+                        break;
+                }
+            }
+        } catch (Exception e) {
+            Insider.Instance.putException(e);
+        }
+        return mappedCustomParameters;
+    }
 }

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['@react-native/babel-preset'],
+};

package/index.d.ts

@@ -1,9 +1,20 @@
-import type RNInsiderProduct from '.src/InsiderProduct';
+import type RNInsiderProduct from './src/InsiderProduct';
 import type RNInsiderEvent from './src/InsiderEvent';
 import type RNInsiderUser from './src/InsiderUser';
 
+export type CustomParameters = {
+  [key: string]: string | number | boolean | Date | number[] | string[];
+};
+
 declare module 'react-native-insider' {
+  export interface InsiderCloseButtonPosition {
+    LEFT: string;
+    RIGHT: string;
+    NONE: string;
+  }
+
   export default class RNInsider {
+    static closeButtonPosition: InsiderCloseButtonPosition;
     static init(partnerName: string, appGroup: string, insiderCallback: Function): void;
     static initWithCustomEndpoint(partnerName: string, appGroup: string, endpoint: string, insiderCallback: Function): void;
     static reinitWithPartnerName(partnerName: string): void;
@@ -20,13 +31,13 @@ declare module 'react-native-insider' {
       price: number,
       currency: string
     ): RNInsiderProduct;
-    static itemPurchased(uniqueSaleID: string, product: RNInsiderProduct): void;
-    static itemAddedToCart(product: RNInsiderProduct): void;
-    static itemRemovedFromCart(productID: string): void;
-    static cartCleared(): void;
-    static itemAddedToWishlist(product: RNInsiderProduct): void;
-    static itemRemovedFromWishlist(productID: string): void;
-    static wishlistCleared(): void;
+    static itemPurchased(uniqueSaleID: string, product: RNInsiderProduct, customParameters?: CustomParameters): void;
+    static itemAddedToCart(product: RNInsiderProduct, customParameters?: CustomParameters): void;
+    static itemRemovedFromCart(productID: string, customParameters?: CustomParameters): void;
+    static cartCleared(customParameters?: CustomParameters): void;
+    static itemAddedToWishlist(product: RNInsiderProduct, customParameters?: CustomParameters): void;
+    static itemRemovedFromWishlist(productID: string, customParameters?: CustomParameters): void;
+    static wishlistCleared(customParameters?: CustomParameters): void;
     static getMessageCenterData(
       limit: number,
       startDate: Date,
@@ -40,16 +51,16 @@ declare module 'react-native-insider' {
       callback: (recommendation: any) => void
     ): void;
     static getSmartRecommendationWithProduct(
-      product: RNInsiderProduct, 
-      recommendationID: number, 
-      locale: string, 
+      product: RNInsiderProduct,
+      recommendationID: number,
+      locale: string,
       callback: (recommendation: any) => void
     ): void;
     static getSmartRecommendationWithProductIDs(
-      productIDs: string[], 
-      recommendationID: number, 
-      locale: string, 
-      currency: string, 
+      productIDs: string[],
+      recommendationID: number,
+      locale: string,
+      currency: string,
       callback: (recommendation: any) => void
     ): void;
     static clickSmartRecommendationProduct(recommendationID: number, product: RNInsiderProduct): void;
@@ -60,40 +71,40 @@ declare module 'react-native-insider' {
       callback: (content: string) => void
     ): void;
     static getContentBoolWithName(
-      variableName: string, 
-      defaultValue: boolean, 
-      contentOptimizerDataType: number, 
+      variableName: string,
+      defaultValue: boolean,
+      contentOptimizerDataType: number,
       callback: (content: boolean) => void
     ): void;
     static getContentIntWithName(
-      variableName: string, 
-      defaultValue: number, 
-      contentOptimizerDataType: number, 
+      variableName: string,
+      defaultValue: number,
+      contentOptimizerDataType: number,
       callback: (content: number) => void
     ): void;
     static getContentStringWithoutCache(
-        variableName: string,
-        defaultValue: string,
-        contentOptimizerDataType: number,
-        callback: (content: string) => void
+      variableName: string,
+      defaultValue: string,
+      contentOptimizerDataType: number,
+      callback: (content: string) => void
     ): void;
     static getContentBoolWithoutCache(
-        variableName: string,
-        defaultValue: boolean,
-        contentOptimizerDataType: number,
-        callback: (content: boolean) => void
+      variableName: string,
+      defaultValue: boolean,
+      contentOptimizerDataType: number,
+      callback: (content: boolean) => void
     ): void;
     static getContentIntWithoutCache(
-        variableName: string,
-        defaultValue: number,
-        contentOptimizerDataType: number,
-        callback: (content: number) => void
+      variableName: string,
+      defaultValue: number,
+      contentOptimizerDataType: number,
+      callback: (content: number) => void
     ): void;
-    static visitHomePage(): void;
-    static visitListingPage(taxonomy: Array<string>): void;
-    static visitProductDetailPage(product: RNInsiderProduct): void;
-    static visitCartPage(products: Array<RNInsiderProduct>): void;
-    static visitWishlistPage(products: Array<RNInsiderProduct>): void;
+    static visitHomePage(customParameters?: CustomParameters): void;
+    static visitListingPage(taxonomy: Array<string>, customParameters?: CustomParameters): void;
+    static visitProductDetailPage(product: RNInsiderProduct, customParameters?: CustomParameters): void;
+    static visitCartPage(products: Array<RNInsiderProduct>, customParameters?: CustomParameters): void;
+    static visitWishlistPage(products: Array<RNInsiderProduct>, customParameters?: CustomParameters): void;
     static startTrackingGeofence(): void;
     static setAllowsBackgroundLocationUpdates(allowsBackgroundLocationUpdates: boolean): void;
     static handleNotification(notification: any): void;
@@ -105,7 +116,8 @@ declare module 'react-native-insider' {
     static enableLocationCollection(consentStatus: boolean): void;
     static enableIpCollection(consentStatus: boolean): void;
     static enableCarrierCollection(consentStatus: boolean): void;
-    static signUpConfirmation(): void;
+    static signUpConfirmation(customParameters?: CustomParameters): void;
+    static setInternalBrowserCloseButtonPosition(position: string): void;
     static reenableTemplatesForIOS(): void;
     static disableTemplatesForIOS(): void;
     static setForegroundPushCallback(callback: (notification: any) => void): void;

package/index.js

@@ -1,9 +1,10 @@
 import { Platform, NativeModules, NativeEventEmitter } from 'react-native';
 
-import { shouldNotProceed, generateJSONErrorString, checkParameters, showParameterWarningLog } from './src/Util';
+import { shouldNotProceed, generateJSONErrorString, checkParameters, showParameterWarningLog, parseObjectWithTypes } from './src/Util';
 import RNInsiderEvent from './src/InsiderEvent';
 import RNInsiderUser from './src/InsiderUser';
 import RNInsiderProduct from './src/InsiderProduct';
+import CloseButtonPosition from './src/CloseButtonPosition';
 
 var packageJSON = require('./package.json');
 
@@ -41,6 +42,8 @@ function registerInsiderCallback(insiderCallback) {
 }
 
 export default class RNInsider {
+  static closeButtonPosition = CloseButtonPosition;
+
   static init(partnerName, appGroup, insiderCallback) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'string', value: partnerName }, { type: 'string', value: appGroup }, { type: 'function', value: insiderCallback }])) {
@@ -171,7 +174,7 @@ export default class RNInsider {
     return new RNInsiderProduct(productID, name, taxonomy, imageURL, price, currency);
   }
 
-  static itemPurchased(uniqueSaleID, product) {
+  static itemPurchased(uniqueSaleID, product, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([
       { type: 'string', value: uniqueSaleID },
@@ -184,69 +187,76 @@ export default class RNInsider {
       return;
     }
     try {
-      Insider.itemPurchased(uniqueSaleID, product.requiredFields, product.optionalFields, product.customParameters);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.itemPurchased(uniqueSaleID, product.requiredFields, product.optionalFields, product.customParameters, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static itemAddedToCart(product) {
+  static itemAddedToCart(product, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'object', value: product }])) {
       showParameterWarningLog("itemAddedToCart", [{ type: 'object', value: product }]);
       return;
     }
     try {
-      Insider.itemAddedToCart(product.requiredFields, product.optionalFields, product.customParameters);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.itemAddedToCart(product.requiredFields, product.optionalFields, product.customParameters, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static itemRemovedFromCart(productID) {
+  static itemRemovedFromCart(productID, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'string', value: productID }])) {
       showParameterWarningLog("itemRemovedFromCart", [{ type: 'string', value: productID }]);
       return;
     }
     try {
-      Insider.itemRemovedFromCart(productID);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.itemRemovedFromCart(productID, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static cartCleared() {
+  static cartCleared(customParameters) {
     if (shouldNotProceed()) return;
     try {
-      Insider.cartCleared();
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.cartCleared(mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static itemAddedToWishlist(product) {
+  static itemAddedToWishlist(product, customParameters) {
     if (shouldNotProceed() || product == null) return;
     try {
-      Insider.itemAddedToWishlist(product.requiredFields, product.optionalFields, product.customParameters);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.itemAddedToWishlist(product.requiredFields, product.optionalFields, product.customParameters, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static itemRemovedFromWishlist(productID) {
+  static itemRemovedFromWishlist(productID, customParameters) {
     if (shouldNotProceed() || productID == null) return;
     try {
-      Insider.itemRemovedFromWishlist(productID);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.itemRemovedFromWishlist(productID, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static wishlistCleared() {
+  static wishlistCleared(customParameters) {
     if (shouldNotProceed()) return;
     try {
-      Insider.wishlistCleared();
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.wishlistCleared(mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -526,42 +536,45 @@ export default class RNInsider {
 
 
   // Visit Pages
-  static visitHomePage() {
+  static visitHomePage(customParameters) {
     if (shouldNotProceed()) return;
     try {
-      Insider.visitHomePage();
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.visitHomePage(mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static visitListingPage(taxonomy) {
+  static visitListingPage(taxonomy, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'object', value: taxonomy }])) {
         showParameterWarningLog("visitListingPage", [{ type: 'object', value: taxonomy }]);
         return;
     }
     try {
-      Insider.visitListingPage(taxonomy);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.visitListingPage(taxonomy, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static visitProductDetailPage(product) {
+  static visitProductDetailPage(product, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'object', value: product }])) {
         showParameterWarningLog("visitProductDetailPage", [{ type: 'object', value: product }]);
         return;
     }
     try {
-      Insider.visitProductDetailPage(product.requiredFields, product.optionalFields, product.customParameters);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.visitProductDetailPage(product.requiredFields, product.optionalFields, product.customParameters, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static visitCartPage(products) {
+  static visitCartPage(products, customParameters) {
     if (shouldNotProceed()) return;
     if (checkParameters([{ type: 'object', value: products }])) {
         showParameterWarningLog("visitCartPage", [{ type: 'object', value: products }]);
@@ -573,13 +586,14 @@ export default class RNInsider {
         optionalFields: product.optionalFields,
         customParameters: product.customParameters
       }));
-      Insider.visitCartPage(mappedProducts);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.visitCartPage(mappedProducts, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static visitWishlistPage(products) {
+  static visitWishlistPage(products, customParameters) {
     if (shouldNotProceed() || products == null) return;
     if (checkParameters([{ type: 'object', value: products }])) {
       showParameterWarningLog("visitWishlistPage", [{ type: 'object', value: products }]);
@@ -591,7 +605,8 @@ export default class RNInsider {
         optionalFields: product.optionalFields,
         customParameters: product.customParameters
       }));
-      Insider.visitWishlistPage(mappedProducts);
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.visitWishlistPage(mappedProducts, mappedCustomParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -730,11 +745,25 @@ export default class RNInsider {
     }
   }
 
-  static signUpConfirmation() {
+  static signUpConfirmation(customParameters) {
     if (shouldNotProceed()) return;
 
     try {
-      Insider.signUpConfirmation();
+      const mappedCustomParameters = parseObjectWithTypes(customParameters);
+      Insider.signUpConfirmation(mappedCustomParameters);
+    } catch (error) {
+      Insider.putErrorLog(generateJSONErrorString(error));
+    }
+  }
+
+  static setInternalBrowserCloseButtonPosition(position) {
+    if (shouldNotProceed() || Platform.OS !== platformType.android) return;
+    if (checkParameters([{ type: 'string', value: position }])) {
+        showParameterWarningLog("setInternalBrowserCloseButtonPosition", [{ type: 'string', value: position }]);
+        return;
+    }
+    try {
+      Insider.setInternalBrowserCloseButtonPosition(position);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }

package/ios/RNInsider/RNInsider.m

@@ -376,69 +376,117 @@ RCT_EXPORT_METHOD(setMobileAppAccess:(BOOL)mobileAppAccess) {
     }
 }
 
-RCT_EXPORT_METHOD(signUpConfirmation) {
+RCT_EXPORT_METHOD(signUpConfirmation:(NSArray *)customParameters) {
     @try {
-        [Insider signUpConfirmation];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider signUpConfirmationWithCustomParameters:mappedCustomParameters];
+        } else {
+            [Insider signUpConfirmation];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
 // Insider Product
-RCT_EXPORT_METHOD(itemPurchased:(NSString *)saleID requiredFields:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters) {
+RCT_EXPORT_METHOD(itemPurchased:(NSString *)saleID requiredFields:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters eventCustomParameters:(NSArray *)eventCustomParameters) {
     @try {
         InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
-        [Insider itemPurchasedWithSaleID:saleID product:product];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:eventCustomParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider itemPurchasedWithSaleID:saleID product:product customParameters:mappedCustomParameters];
+        } else {
+            [Insider itemPurchasedWithSaleID:saleID product:product];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(itemAddedToCart:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters) {
+RCT_EXPORT_METHOD(itemAddedToCart:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters eventCustomParameters:(NSArray *)eventCustomParameters) {
     @try {
         InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
-        [Insider itemAddedToCartWithProduct:product];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:eventCustomParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider itemAddedToCartWithProduct:product customParameters:mappedCustomParameters];
+        } else {
+            [Insider itemAddedToCartWithProduct:product];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(itemRemovedFromCart:(NSString *)productID) {
+RCT_EXPORT_METHOD(itemRemovedFromCart:(NSString *)productID customParameters:(NSArray *)customParameters) {
     @try {
-        [Insider itemRemovedFromCartWithProductID:productID];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider itemRemovedFromCartWithProductID:productID customParameters:mappedCustomParameters];
+        } else {
+            [Insider itemRemovedFromCartWithProductID:productID];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(cartCleared) {
+RCT_EXPORT_METHOD(cartCleared:(NSArray *)customParameters) {
     @try {
-        [Insider cartCleared];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider cartClearedWithCustomParameters:mappedCustomParameters];
+        } else {
+            [Insider cartCleared];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(itemAddedToWishlist:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters) {
+RCT_EXPORT_METHOD(itemAddedToWishlist:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters eventCustomParameters:(NSArray *)eventCustomParameters) {
     @try {
         InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
-        [Insider itemAddedToWishlistWithProduct:product];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:eventCustomParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider itemAddedToWishlistWithProduct:product customParameters:mappedCustomParameters];
+        } else {
+            [Insider itemAddedToWishlistWithProduct:product];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(itemRemovedFromWishlist:(NSString *)productID) {
+RCT_EXPORT_METHOD(itemRemovedFromWishlist:(NSString *)productID customParameters:(NSArray *)customParameters) {
     @try {
-        [Insider itemRemovedFromWishlistWithProductID:productID];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider itemRemovedFromWishlistWithProductID:productID customParameters:mappedCustomParameters];
+        } else {
+            [Insider itemRemovedFromWishlistWithProductID:productID];
+        }
     } @catch (NSException *e){
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(wishlistCleared) {
+RCT_EXPORT_METHOD(wishlistCleared:(NSArray *)customParameters) {
         @try {
-            [Insider wishlistCleared];
+            NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+            if (mappedCustomParameters.count > 0) {
+                [Insider wishlistClearedWithCustomParameters:mappedCustomParameters];
+            } else {
+                [Insider wishlistCleared];
+            }
         } @catch (NSException *e){
             [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
         }
@@ -544,58 +592,90 @@ RCT_EXPORT_METHOD(getContentIntWithoutCache:(NSString *)variableName defaultValu
     }
 }
 
-RCT_EXPORT_METHOD(visitHomePage) {
+RCT_EXPORT_METHOD(visitHomePage:(NSArray *)customParameters) {
     @try {
-        [Insider visitHomepage];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider visitHomepageWithCustomParameters:mappedCustomParameters];
+        } else {
+            [Insider visitHomepage];
+        }
     } @catch (NSException *e) {
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(visitListingPage:(NSArray *)taxonomy) {
+RCT_EXPORT_METHOD(visitListingPage:(NSArray *)taxonomy customParameters:(NSArray *)customParameters) {
     @try {
-        [Insider visitListingPageWithTaxonomy:taxonomy];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider visitListingPageWithTaxonomy:taxonomy customParameters:mappedCustomParameters];
+        } else {
+            [Insider visitListingPageWithTaxonomy:taxonomy];
+        }
     } @catch (NSException *e) {
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(visitProductDetailPage:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters) {
+RCT_EXPORT_METHOD(visitProductDetailPage:(NSDictionary *)requiredFields optionalFields:(NSDictionary *)optionalFields customParameters:(NSArray *)customParameters eventCustomParameters:(NSArray *)eventCustomParameters) {
     @try {
         InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
-        [Insider visitProductDetailPageWithProduct:product];
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:eventCustomParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider visitProductDetailPageWithProduct:product customParameters:mappedCustomParameters];
+        } else {
+            [Insider visitProductDetailPageWithProduct:product];
+        }
     } @catch (NSException *e) {
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(visitCartPage:(NSArray *)products) {
+RCT_EXPORT_METHOD(visitCartPage:(NSArray *)products customParameters:(NSArray *)customParameters) {
     @try {
         NSMutableArray<InsiderProduct *> *mappedProducts = [NSMutableArray array];
         for (NSDictionary *productDict in products) {
             NSDictionary *requiredFields = productDict[@"requiredFields"];
             NSDictionary *optionalFields = productDict[@"optionalFields"];
-            NSArray *customParameters = productDict[@"customParameters"];
-            InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
+            NSArray *productCustomParameters = productDict[@"customParameters"];
+            InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:productCustomParameters];
             [mappedProducts addObject:product];
         }
-        [Insider visitCartPageWithProducts:[mappedProducts copy]];
+
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider visitCartPageWithProducts:[mappedProducts copy] customParameters:mappedCustomParameters];
+        } else {
+            [Insider visitCartPageWithProducts:[mappedProducts copy]];
+        }
     } @catch (NSException *e) {
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }
 }
 
-RCT_EXPORT_METHOD(visitWishlistPage:(NSArray *)products) {
+RCT_EXPORT_METHOD(visitWishlistPage:(NSArray *)products customParameters:(NSArray *)customParameters) {
     @try {
         NSMutableArray<InsiderProduct *> *mappedProducts = [NSMutableArray array];
         for (NSDictionary *productDict in products) {
             NSDictionary *requiredFields = productDict[@"requiredFields"];
             NSDictionary *optionalFields = productDict[@"optionalFields"];
-            NSArray *customParameters = productDict[@"customParameters"];
-            InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:customParameters];
+            NSArray *productCustomParameters = productDict[@"customParameters"];
+            InsiderProduct *product = [RNUtils parseProductFromRequiredFields:requiredFields andOptionalFields:optionalFields andCustomParameters:productCustomParameters];
             [mappedProducts addObject:product];
         }
-        [Insider visitWishlistWithProducts:[mappedProducts copy]];
+
+        NSDictionary<NSString *, id> *mappedCustomParameters = [RNUtils parseCustomParameters:customParameters];
+
+        if (mappedCustomParameters.count > 0) {
+            [Insider visitWishlistWithProducts:[mappedProducts copy] customParameters:mappedCustomParameters];
+        } else {
+            [Insider visitWishlistWithProducts:[mappedProducts copy]];
+        }
     } @catch (NSException *e) {
         [Insider sendError:e desc:[NSString stringWithFormat:@"%s:%d", __func__, __LINE__]];
     }

package/ios/RNInsider/RNUtils.h

@@ -23,4 +23,6 @@
                                          andOptionalFields:(nullable NSDictionary *)optionalFields
                                        andCustomParameters:(nullable NSArray *)customParameters;
 
++ (nonnull NSDictionary<NSString *, id> *)parseCustomParameters:(nonnull NSArray *)customParameters;
+
 @end

package/ios/RNInsider/RNUtils.m

@@ -245,4 +245,42 @@
     return product;
 }
 
++ (nonnull NSDictionary<NSString *, id> *)parseCustomParameters:(nonnull NSArray *)customParameters {
+    NSMutableDictionary<NSString *, id> *mappedCustomParameters = [NSMutableDictionary dictionary];
+
+    for (id item in customParameters) {
+        if (![item isKindOfClass:[NSDictionary class]]) continue;
+
+        NSDictionary *parameter = (NSDictionary *)item;
+        NSString *type = parameter[@"type"];
+        NSString *key  = parameter[@"key"];
+
+        if (![type isKindOfClass:[NSString class]] || ![key isKindOfClass:[NSString class]]) continue;
+
+        id value = parameter[@"value"];
+
+        if ([type isEqualToString:@"string"] && [value isKindOfClass:[NSString class]]) {
+            NSString *stringValue = (NSString *)value;
+            mappedCustomParameters[key] = stringValue;
+        }
+        else if (([type isEqualToString:@"integer"] || [type isEqualToString:@"double"] || [type isEqualToString:@"boolean"]) && [value isKindOfClass:[NSNumber class]]) {
+            NSNumber *numberValue = (NSNumber *)value;
+            mappedCustomParameters[key] = numberValue;
+        }
+        else if ([type isEqualToString:@"date"] && [value isKindOfClass:[NSNumber class]]) {
+            NSNumber *numberValue = (NSNumber *)value;
+            long long epochMillis = numberValue.longLongValue;
+            NSTimeInterval seconds = ((NSTimeInterval)epochMillis) / 1000.0;
+            NSDate *dateValue = [NSDate dateWithTimeIntervalSince1970:seconds];
+            mappedCustomParameters[key] = dateValue;
+        }
+        else if (([type isEqualToString:@"numeric_array"] || [type isEqualToString:@"string_array"]) && [value isKindOfClass:[NSArray class]]) {
+            NSArray *arrayValue = (NSArray *)value;
+            mappedCustomParameters[key] = arrayValue;
+        }
+    }
+
+    return mappedCustomParameters;
+}
+
 @end

package/package.json

@@ -1,9 +1,12 @@
 {
     "name": "react-native-insider",
-    "version": "7.0.11",
+    "version": "7.0.12",
     "description": "React Native Insider SDK",
     "main": "index.js",
     "types": "index.d.ts",
+    "scripts": {
+        "test": "jest"
+    },
     "keywords": [
         "react-native",
         "ios",
@@ -15,5 +18,21 @@
         "insider"
     ],
     "author": "insidermobile",
-    "homepage": "https://github.com/useinsider/react-native-insider"
-}
+    "homepage": "https://github.com/useinsider/react-native-insider",
+    "devDependencies": {
+        "@babel/core": "^7.20.0",
+        "@babel/preset-env": "^7.20.0",
+        "@react-native/babel-preset": "0.83.0",
+        "babel-jest": "^30.2.0",
+        "jest": "^29.7.0",
+        "react": "19.2.0",
+        "react-native": "0.83.0"
+    },
+    "jest": {
+        "preset": "react-native",
+        "modulePathIgnorePatterns": [
+            "<rootDir>/example/node_modules",
+            "<rootDir>/lib/"
+        ]
+    }
+}

package/src/CloseButtonPosition.js

@@ -0,0 +1,6 @@
+const CloseButtonPosition = {
+  LEFT: "LEFT",
+  RIGHT: "RIGHT",
+  NONE: "NONE"
+};
+export default CloseButtonPosition;

package/src/Util.js

@@ -33,3 +33,64 @@ export function showParameterWarningLog(functionName, parameters = []) {
     `Invalid Parameters:\n${invalidParams.join("\n")}`
   );
 }
+
+export function isPlainObject(value) {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+
+  return Object.getPrototypeOf(value) === Object.prototype ||
+         Object.getPrototypeOf(value) === null;
+}
+
+export function detectType(value) {
+  if (typeof value === 'boolean') {
+    return 'boolean';
+  }
+
+  if (value instanceof Date) {
+    return 'date';
+  }
+
+  if (Array.isArray(value)) {
+    if (value.every(item => typeof item === 'number')) {
+      return 'numeric_array';
+    }
+
+    if (value.every(item => typeof item === 'string')) {
+      return 'string_array';
+    }
+
+    return 'unknown';
+  }
+
+  if (typeof value === 'number' && !isNaN(value)) {
+    if (Number.isInteger(value)) {
+      return 'integer';
+    }
+
+    return 'double';
+  }
+
+  if (typeof value === 'string') {
+    return 'string';
+  }
+
+  return 'unknown';
+}
+
+export function parseObjectWithTypes(parameters) {
+  if (!isPlainObject(parameters)) {
+    return [];
+  }
+
+  return Object.entries(parameters).map(([key, value]) => {
+    const type = detectType(value);
+
+    return {
+      key: key,
+      type: type,
+      value: type === 'date' ? value.getTime() : value
+    };
+  }).filter(param => param.type !== 'unknown');
+}