react-native-insider 7.0.5-nh → 7.0.6-nh

package/.claude/commands/pr-description.md

@@ -0,0 +1,40 @@
+---
+description: Generate PR description using project template
+argument-hint: "[base-branch]"
+---
+
+Generate a PR description using the template in .github/pull_request_template.md file.
+
+If the user provided a base branch argument, use that: $1
+Otherwise, automatically detect the base branch by:
+1. First checking if there's an upstream branch set
+2. If not, use the default main branch (develop, main, or master)
+
+Compare the current branch against this base branch.
+
+Requirements:
+- Write the description as markdown text
+- This is a React Native SDK project with iOS (Objective-C) and Android (Java) native modules
+- Highlight code elements (classes, methods, imports, etc.) using backticks
+- Never mention classes with full paths, just wrap class names with backticks (e.g., `InsiderIdentifier` not `src/InsiderIdentifier.js`)
+- For native code references, use simple class names: `RNInsider` (not `ios/RNInsider/RNInsider.m`) or `RNInsiderModule` (not `android/src/main/java/com/useinsider/react/RNInsiderModule.java`)
+- If the current branch name contains the format "MOB-[0-9]+" (e.g., feature/MOB-1234), extract the ticket number and create a JIRA URL: https://winsider.atlassian.net/browse/MOB-XXXX
+- Include manual testing recommendations in the test cases section of the template
+- Keep it high-level and avoid getting into too much technical detail
+- Focus on what changed and why, not the implementation details
+- When describing changes, specify if they affect iOS, Android, or both platforms
+
+Output Format:
+- **IMPORTANT**: Wrap the entire PR description in a markdown code block using triple backticks (```markdown ... ```)
+- This allows the user to easily copy the raw markdown without formatting issues
+- The output should be a single markdown code block containing all the PR description content
+
+Steps:
+1. Read the PR template from .github/pull_request_template.md
+2. Get the git diff comparing current branch against the base branch
+3. Get the commit history for context
+4. Extract the JIRA ticket number from the branch name if present
+5. Analyze the changes across iOS, Android, and JavaScript/TypeScript code
+6. Identify which platform(s) are affected (iOS, Android, or both)
+7. Generate a clear, concise PR description following the template format
+8. Wrap the entire output in a ```markdown code block for easy copying

package/.claude/settings.json

@@ -0,0 +1,34 @@
+{
+    "permissions": {
+      "allow": [
+        "Bash(git:*)",
+        "Bash(npm run:*)",
+        "Edit(ios/**)",
+        "Edit(index.d.ts)",
+        "Edit(index.js)",
+        "Edit(src/**)",
+        "Edit(android/**)",
+        "Read(.github/**)",
+        "Read(.claude/**)",
+        "WebSearch",
+        "WebFetch(domain:academy.insiderone.com)"
+      ],
+      "deny": [
+        "Bash(sudo:*)",
+        "Bash(curl:*)",
+        "Bash(wget:*)",
+        "Bash(fetch:*)",
+        "Bash(git push:*)",
+        "Bash(git push --force:*)",
+        "Read(./.env*)",
+        "Read(./secrets/**)",
+        "Read(./config/credentials.json)"
+      ],
+      "ask": [
+        "Bash(pod install:*)",
+        "Bash(pod update:*)",
+        "Bash(rm:*)",
+        "Bash(git commit:*)"
+      ]
+    }
+  }

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.2/InsiderMobileIOSFramework.zip'}
+  s.source = {:http => 'https://mobilesdk.useinsider.com/iOS/14.2.3/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.2'
+  s.dependency 'InsiderMobile', '14.2.3'
   s.dependency 'InsiderGeofence', '1.2.4'
   s.dependency 'InsiderHybrid', '1.7.6'
 end

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

@@ -31,7 +31,7 @@ import com.useinsider.insider.InsiderIDListener;
 import org.json.JSONArray;
 import org.json.JSONObject;
 
-import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -124,9 +124,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void tagEvent(String eventName, ReadableMap parameters) {
+    public void tagEvent(String eventName, ReadableArray parameters) {
         try {
-            InsiderHybrid.tagEvent(eventName, RNUtils.convertReadableMapToMap(parameters));
+            RNUtils.parseEvent(eventName, parameters).build();
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -144,7 +144,10 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void setBirthday(String birthday) {
         try {
-            InsiderHybrid.setBirthday(birthday);
+            // React Native's bridge does not support long type directly, so we use String to pass epoch time.
+            long birthdayEpoch = Long.parseLong(birthday);
+            Date birthdayDate = new Date(birthdayEpoch);
+            Insider.Instance.getCurrentUser().setBirthday(birthdayDate);
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -298,7 +301,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         }
     }
 
-    private InsiderIdentifiers setIdentifiers (ReadableMap identifiers) {
+    private InsiderIdentifiers setIdentifiers(ReadableMap identifiers) {
         try {
             HashMap<String, Object> mappedIdentifiers = RNUtils.convertReadableMapToMap(identifiers);
             InsiderIdentifiers insiderIdentifiers = new InsiderIdentifiers();
@@ -411,7 +414,10 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void setCustomAttributeWithDate(String key, String value) {
         try {
-            InsiderHybrid.setCustomAttributeWithDate(key, value);
+            // React Native's bridge does not support long type directly, so we use String to pass epoch time.
+            long valueEpoch = Long.parseLong(value);
+            Date valueDate = new Date(valueEpoch);
+            Insider.Instance.getCurrentUser().setCustomAttributeWithDate(key, valueDate);
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -459,10 +465,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void itemPurchased(String saleID, ReadableMap productMustMap, ReadableMap productOptMap) {
+    public void itemPurchased(String saleID, ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.itemPurchased(saleID, product);
         } catch (Exception e) {
             Insider.Instance.putException(e);
@@ -470,10 +475,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void itemAddedToCart(ReadableMap productMustMap, ReadableMap productOptMap) {
+    public void itemAddedToCart(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.itemAddedToCart(product);
         } catch (Exception e) {
             Insider.Instance.putException(e);
@@ -499,10 +503,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void itemAddedToWishlist(ReadableMap productMustMap, ReadableMap productOptMap) {
+    public void itemAddedToWishlist(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.itemAddedToWishlist(product);
         } catch (Exception e) {
             Insider.Instance.putException(e);
@@ -570,11 +573,10 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void getSmartRecommendationWithProduct(ReadableMap productMustMap, ReadableMap productOptMap,
+    public void getSmartRecommendationWithProduct(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters,
                                                   int recommendationID, String locale, final Callback callback) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.getSmartRecommendationWithProduct(product, recommendationID, locale,
                     new RecommendationEngine.SmartRecommendation() {
                         @Override
@@ -613,11 +615,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void clickSmartRecommendationProduct(int recommendationID, ReadableMap productMustMap,
-                                                ReadableMap productOptMap) {
+    public void clickSmartRecommendationProduct(int recommendationID, ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.clickSmartRecommendationProduct(recommendationID, product);
         } catch (Exception e) {
             Insider.Instance.putException(e);
@@ -705,10 +705,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void visitProductDetailPage(ReadableMap productMustMap, ReadableMap productOptMap) {
+    public void visitProductDetailPage(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
         try {
-            HashMap optMap = RNUtils.fixIntegerAttributesInMap(RNUtils.convertReadableMapToMap(productOptMap));
-            InsiderProduct product = InsiderHybrid.createProduct(RNUtils.convertReadableMapToMap(productMustMap), optMap);
+            InsiderProduct product = RNUtils.parseProduct(requiredFields, optionalFields, customParameters);
             Insider.Instance.visitProductDetailPage(product);
         } catch (Exception e) {
             Insider.Instance.putException(e);
@@ -720,10 +719,11 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         try {
             InsiderProduct[] ips = new InsiderProduct[products.size()];
             for (int i = 0; i < products.size(); i++) {
-                HashMap productsMap = RNUtils.convertReadableMapToMap(products.getMap(i));
-                HashMap optMap = RNUtils.fixIntegerAttributesInMap((HashMap<String, Object>) productsMap.get("productOptMap"));
-                InsiderProduct product = InsiderHybrid
-                        .createProduct((HashMap<String, Object>) productsMap.get("productMustMap"), optMap);
+                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);
                 ips[i] = product;
             }
             Insider.Instance.visitCartPage(ips);
@@ -737,10 +737,11 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         try {
             InsiderProduct[] ips = new InsiderProduct[products.size()];
             for (int i = 0; i < products.size(); i++) {
-                HashMap productsMap = RNUtils.convertReadableMapToMap(products.getMap(i));
-                HashMap optMap = RNUtils.fixIntegerAttributesInMap((HashMap<String, Object>) productsMap.get("productOptMap"));
-                InsiderProduct product = InsiderHybrid
-                        .createProduct((HashMap<String, Object>) productsMap.get("productMustMap"), optMap);
+                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);
                 ips[i] = product;
             }
             Insider.Instance.visitWishlistPage(ips);

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

@@ -9,18 +9,17 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.useinsider.insider.Insider;
+import com.useinsider.insider.InsiderEvent;
+import com.useinsider.insider.InsiderProduct;
 
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 
 public class RNUtils {
@@ -30,7 +29,7 @@ public class RNUtils {
         try {
             for (String key : map.keySet()) {
                 writableMap.putString(key, map.get(key));
-            }    
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -86,7 +85,7 @@ public class RNUtils {
                 } else {
                     map.putString(key, value.toString());
                 }
-            }       
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -117,13 +116,12 @@ public class RNUtils {
                         ReadableArray array = readableMap.getArray(key);
                         if (isConvertibleToNumericArray(array)) {
                             map.put(key, convertReadableArrayToNumericArray(array));
-                        }
-                        else {
+                        } else {
                             map.put(key, convertReadableArrayToStringArray(array));
                         }
                         break;
                 }
-            }    
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -190,4 +188,195 @@ public class RNUtils {
         }
         return true;
     }
+
+    static InsiderEvent parseEvent(String eventName, ReadableArray parameters) {
+        InsiderEvent event = Insider.Instance.tagEvent(eventName);
+
+        for (int i = 0; i < parameters.size(); i++) {
+            ReadableMap parameter = parameters.getMap(i);
+            if (parameter == null) continue;
+
+            String type = parameter.getString("type");
+            String key = parameter.getString("key");
+            if (type == null || key == null) continue;
+
+            switch (type) {
+                case "string":
+                    String stringValue = parameter.getString("value");
+                    event.addParameterWithString(key, stringValue);
+                    break;
+                case "integer":
+                    int intValue = parameter.getInt("value");
+                    event.addParameterWithInt(key, intValue);
+                    break;
+                case "double":
+                    double doubleValue = parameter.getDouble("value");
+                    event.addParameterWithDouble(key, doubleValue);
+                    break;
+                case "boolean":
+                    boolean booleanValue = parameter.getBoolean("value");
+                    event.addParameterWithBoolean(key, booleanValue);
+                    break;
+                case "date":
+                    // React Native's bridge does not support long type directly, so we use String to pass epoch time.
+                    long epochValue = Long.parseLong(parameter.getString("value"));
+                    Date dateValue = new Date(epochValue);
+                    event.addParameterWithDate(key, dateValue);
+                    break;
+                case "strings":
+                    ReadableArray stringsArray = parameter.getArray("value");
+                    String[] stringsValue = RNUtils.convertReadableArrayToStringArray(stringsArray);
+                    event.addParameterWithStringArray(key, stringsValue);
+                    break;
+                case "numbers":
+                    ReadableArray numbersArray = parameter.getArray("value");
+                    Number[] numbersValue = RNUtils.convertReadableArrayToNumericArray(numbersArray);
+                    event.addParameterWithNumericArray(key, numbersValue);
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unknown parameter type received.");
+            }
+        }
+
+        return event;
+    }
+
+    static InsiderProduct parseProduct(ReadableMap requiredFields, ReadableMap optionalFields, ReadableArray customParameters) {
+        // apply required fields
+        String productId = requiredFields.getString("product_id");
+        String name = requiredFields.getString("name");
+        ReadableArray taxonomyReadableArray = requiredFields.getArray("taxonomy");
+        String[] taxonomy = RNUtils.convertReadableArrayToStringArray(taxonomyReadableArray);
+        String imageURL = requiredFields.getString("image_url");
+        double price = requiredFields.getDouble("price");
+        String currency = requiredFields.getString("currency");
+        InsiderProduct product = Insider.Instance.createNewProduct(productId, name, taxonomy, imageURL, price, currency);
+
+        // apply optional fields
+        Iterator<Map.Entry<String, Object>> optionalIterator = optionalFields.getEntryIterator();
+        while (optionalIterator.hasNext()) {
+            Map.Entry<String, Object> parameter = optionalIterator.next();
+            String key = parameter.getKey();
+            Object value = parameter.getValue();
+
+            switch (key) {
+                case "color":
+                    product.setColor((String) value);
+                    break;
+                case "voucher_name":
+                    product.setVoucherName((String) value);
+                    break;
+                case "promotion_name":
+                    product.setPromotionName((String) value);
+                    break;
+                case "size":
+                    product.setSize((String) value);
+                    break;
+                case "sale_price":
+                    product.setSalePrice((double) value);
+                    break;
+                case "shipping_cost":
+                    product.setShippingCost((double) value);
+                    break;
+                case "voucher_discount":
+                    product.setVoucherDiscount((double) value);
+                    break;
+                case "promotion_discount":
+                    product.setPromotionDiscount((double) value);
+                    break;
+                case "stock":
+                    Double stockNumber = (Double) value;
+                    product.setStock(stockNumber.intValue());
+                    break;
+                case "quantity":
+                    Double quantityNumber = (Double) value;
+                    product.setQuantity(quantityNumber.intValue());
+                    break;
+                case "group_code":
+                    product.setGroupCode((String) value);
+                    break;
+                case "brand":
+                    product.setBrand((String) value);
+                    break;
+                case "sku":
+                    product.setSku((String) value);
+                    break;
+                case "gender":
+                    product.setGender((String) value);
+                    break;
+                case "multipack":
+                    product.setMultipack((String) value);
+                    break;
+                case "product_type":
+                    product.setProductType((String) value);
+                    break;
+                case "gtin":
+                    product.setGtin((String) value);
+                    break;
+                case "description":
+                    product.setDescription((String) value);
+                    break;
+                case "tags":
+                    ReadableArray tagsReadableArray = (ReadableArray) value;
+                    String[] tagsArray = RNUtils.convertReadableArrayToStringArray(tagsReadableArray);
+                    product.setTags(tagsArray);
+                    break;
+                case "in_stock":
+                    product.setInStock((boolean) value);
+                    break;
+                case "product_url":
+                    product.setProductURL((String) value);
+                    break;
+            }
+        }
+
+        // apply custom parameters
+        for (int i = 0; i < customParameters.size(); i++) {
+            ReadableMap parameter = customParameters.getMap(i);
+            if (parameter == null) continue;
+
+            String type = parameter.getString("type");
+            String key = parameter.getString("key");
+            if (type == null || key == null) continue;
+
+            switch (type) {
+                case "string":
+                    String stringValue = parameter.getString("value");
+                    product.setCustomAttributeWithString(key, stringValue);
+                    break;
+                case "integer":
+                    int intValue = parameter.getInt("value");
+                    product.setCustomAttributeWithInt(key, intValue);
+                    break;
+                case "double":
+                    double doubleValue = parameter.getDouble("value");
+                    product.setCustomAttributeWithDouble(key, doubleValue);
+                    break;
+                case "boolean":
+                    boolean booleanValue = parameter.getBoolean("value");
+                    product.setCustomAttributeWithBoolean(key, booleanValue);
+                    break;
+                case "date":
+                    // React Native's bridge does not support long type directly, so we use String to pass epoch time.
+                    long epochValue = Long.parseLong(parameter.getString("value"));
+                    Date dateValue = new Date(epochValue);
+                    product.setCustomAttributeWithDate(key, dateValue);
+                    break;
+                case "strings":
+                    ReadableArray stringsArray = parameter.getArray("value");
+                    String[] stringsValue = RNUtils.convertReadableArrayToStringArray(stringsArray);
+                    product.setCustomAttributeWithStringArray(key, stringsValue);
+                    break;
+                case "numbers":
+                    ReadableArray numbersArray = parameter.getArray("value");
+                    Number[] numbersValue = RNUtils.convertReadableArrayToNumericArray(numbersArray);
+                    product.setCustomAttributeWithNumericArray(key, numbersValue);
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unknown parameter type received.");
+            }
+        }
+
+        return product;
+    }
 }

package/index.d.ts

@@ -115,6 +115,20 @@ declare module 'react-native-insider' {
     static insiderIDListener(callback: (insiderID: string) => void): void;
     static disableInAppMessages(): void;
     static enableInAppMessages(): void;
+    /**
+     * Handles deep link URLs from Insider QR codes and email links.
+     * 
+     * This method processes incoming URLs to enable deep linking functionality
+     * for features available in the Insider panel. It parses the URL and routes
+     * the user to the appropriate screen or action within the app, allowing
+     * seamless integration with Insider's panel-based features.
+     * 
+     * @platform iOS only - This method is only available on iOS platform
+     * @param url - The URL string to be processed from Insider QR codes or email links
+     * @example
+     * RNInsider.handleURL('insider{your_partner_name}://test_device/...');
+     */
+    static handleURL(url: string): void;
   }
 
   export const NOTIFICATION_OPEN: string;

package/index.js

@@ -184,7 +184,7 @@ export default class RNInsider {
       return;
     }
     try {
-      Insider.itemPurchased(uniqueSaleID, product.productMustMap, product.productOptMap);
+      Insider.itemPurchased(uniqueSaleID, product.requiredFields, product.optionalFields, product.customParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -197,7 +197,7 @@ export default class RNInsider {
       return;
     }
     try {
-      Insider.itemAddedToCart(product.productMustMap, product.productOptMap);
+      Insider.itemAddedToCart(product.requiredFields, product.optionalFields, product.customParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -225,16 +225,16 @@ export default class RNInsider {
     }
   }
 
-  static itemAddedToWishlist(product: RNInsiderProduct) {
+  static itemAddedToWishlist(product) {
     if (shouldNotProceed() || product == null) return;
     try {
-      Insider.itemAddedToWishlist(product.productMustMap, product.productOptMap);
+      Insider.itemAddedToWishlist(product.requiredFields, product.optionalFields, product.customParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-  static itemRemovedFromWishlist(productID: string) {
+  static itemRemovedFromWishlist(productID) {
     if (shouldNotProceed() || productID == null) return;
     try {
       Insider.itemRemovedFromWishlist(productID);
@@ -329,7 +329,7 @@ export default class RNInsider {
         return;
     }
     try {
-      Insider.getSmartRecommendationWithProduct(product.productMustMap, product.productOptMap, recommendationID, locale, (recommendation) => {
+      Insider.getSmartRecommendationWithProduct(product.requiredFields, product.optionalFields, product.customParameters, recommendationID, locale, (recommendation) => {
         callback(recommendation);
       });
     } catch (error) {
@@ -379,7 +379,7 @@ export default class RNInsider {
         return;
     }
     try {
-      Insider.clickSmartRecommendationProduct(recommendationID, product.productMustMap, product.productOptMap);
+      Insider.clickSmartRecommendationProduct(recommendationID, product.requiredFields, product.optionalFields, product.customParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -555,7 +555,7 @@ export default class RNInsider {
         return;
     }
     try {
-      Insider.visitProductDetailPage(product.productMustMap, product.productOptMap);
+      Insider.visitProductDetailPage(product.requiredFields, product.optionalFields, product.customParameters);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
@@ -567,35 +567,35 @@ export default class RNInsider {
         showParameterWarningLog("visitCartPage", [{ type: 'object', value: products }]);
         return;
     }
-    let mappedProducts = new Array(products.length);
     try {
-        products.forEach((product, i) => {
-            let productMap = {};
-            productMap['productMustMap'] = product.productMustMap;
-            productMap['productOptMap'] = product.productOptMap;
-            mappedProducts[i] = productMap;
-          });
+      const mappedProducts = products.map(product => ({
+        requiredFields: product.requiredFields,
+        optionalFields: product.optionalFields,
+        customParameters: product.customParameters
+      }));
       Insider.visitCartPage(mappedProducts);
     } catch (error) {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
 
-    static visitWishlistPage(products: Array<RNInsiderProduct>) {
-      if (shouldNotProceed() || products == null) return;
-      let mappedProducts = new Array(products.length);
-      try {
-          products.forEach((product, i) => {
-              let productMap = {};
-              productMap['productMustMap'] = product.productMustMap;
-              productMap['productOptMap'] = product.productOptMap;
-              mappedProducts[i] = productMap;
-            });
-        Insider.visitWishlistPage(mappedProducts);
-      } catch (error) {
-        Insider.putErrorLog(generateJSONErrorString(error));
-      }
+  static visitWishlistPage(products) {
+    if (shouldNotProceed() || products == null) return;
+    if (checkParameters([{ type: 'object', value: products }])) {
+      showParameterWarningLog("visitWishlistPage", [{ type: 'object', value: products }]);
+      return;
     }
+    try {
+      const mappedProducts = products.map(product => ({
+        requiredFields: product.requiredFields,
+        optionalFields: product.optionalFields,
+        customParameters: product.customParameters
+      }));
+      Insider.visitWishlistPage(mappedProducts);
+    } catch (error) {
+      Insider.putErrorLog(generateJSONErrorString(error));
+    }
+  }
 
   static startTrackingGeofence() {
     if (shouldNotProceed()) return;
@@ -848,4 +848,16 @@ export default class RNInsider {
       Insider.putErrorLog(generateJSONErrorString(error));
     }
   }
+
+  static handleURL(url) {
+    if (shouldNotProceed()) return;
+
+    try {
+      if (Platform.OS === 'android') return;
+
+      Insider.handleURL(url);
+    } catch (error) {
+      Insider.putErrorLog(generateJSONErrorString(error));
+    }
+  }
 }