fidel-react-native 1.6.4 → 2.0.0

package/android/src/test/java/com/fidelreactlibrary/fakes/ReadableMapStub.java

@@ -1,6 +1,7 @@
 package com.fidelreactlibrary.fakes;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.JavaOnlyArray;
@@ -8,111 +9,245 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableType;
+import com.fidelreactlibrary.adapters.CardVerificationConfigurationProperties;
+import com.fidelreactlibrary.adapters.FidelSetupProperties;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
 public class ReadableMapStub implements ReadableMap {
 
     public List<String> keyNamesCheckedFor = new ArrayList<>();
     public List<String> keyNamesVerifiedNullFor = new ArrayList<>();
-    public List<String> keyNamesAskedFor = new ArrayList<>();
+    public List<String> keyNamesAskedValueFor = new ArrayList<>();
     public HashMap<String, ReadableMap> mapsForKeysToReturn = new HashMap<>();
     public HashMap<String, Object> hashMapToReturn;
     public HashMap<String, String> stringForKeyToReturn = new HashMap<>();
-    public ReadableArray readableArrayToReturn = new JavaOnlyArray();
+    public HashMap<String, ReadableArray> readableArraysToReturn = new HashMap<>();
     public boolean boolToReturn;
-    public int intToReturn;
-    private String hasKeyString = "";
-    private String isNullString = "";
+    private final List<String> hasKeyStrings = new ArrayList<>();
+    private final List<String> isNullStrings = new ArrayList<>();
 
-    public ReadableMapStub() {}
-    private ReadableMapStub(String hasKeyString, String isNullString) {
-        this.hasKeyString = hasKeyString;
-        this.isNullString = isNullString;
+    public ReadableMapStub() {
     }
 
     public static ReadableMapStub mapWithNoKey() {
-        return new ReadableMapStub("", "");
+        return new ReadableMapStub();
+    }
+
+    public static ReadableMapStub mapWithAllValidSetupKeys() {
+        ReadableMapStub mapStub = new ReadableMapStub();
+        String[] keyJsNames = Arrays.stream(FidelSetupProperties.values()).map(FidelSetupProperties::jsName)
+                .toArray(String[]::new);
+        mapStub.hasKeyStrings.addAll(Arrays.asList(keyJsNames));
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.SDK_KEY.jsName(), "pk_test_some_sdk_key");
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.PROGRAM_ID.jsName(), "some test program ID");
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.PROGRAM_TYPE.jsName(), "some test program type");
+        ReadableMapStub optionsReadableMap = ReadableMapStub.optionsMapWithAllValidSetupKeys();
+        mapStub.mapsForKeysToReturn.put(FidelSetupProperties.OPTIONS.jsName(), optionsReadableMap);
+        ReadableMapStub consentTextReadableMap = ReadableMapStub.consentTextMapWithAllValidSetupKeys();
+        mapStub.mapsForKeysToReturn.put(FidelSetupProperties.CONSENT_TEXT.jsName(), consentTextReadableMap);
+        return mapStub;
+    }
+
+    private static ReadableMapStub optionsMapWithAllValidSetupKeys() {
+        ReadableMapStub mapStub = new ReadableMapStub();
+        String[] keyJsNames = Arrays.stream(FidelSetupProperties.Options.values())
+                .map(FidelSetupProperties.Options::jsName)
+                .toArray(String[]::new);
+        mapStub.hasKeyStrings.addAll(Arrays.asList(keyJsNames));
+        mapStub.mapsForKeysToReturn.put(FidelSetupProperties.Options.BANNER_IMAGE.jsName(), new ReadableMapStub());
+        mapStub.readableArraysToReturn.put(FidelSetupProperties.Options.ALLOWED_COUNTRIES.jsName(),
+                new JavaOnlyArray());
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.Options.DEFAULT_SELECTED_COUNTRY.jsName(), "japan");
+        mapStub.readableArraysToReturn.put(FidelSetupProperties.Options.SUPPORTED_CARD_SCHEMES.jsName(),
+                new JavaOnlyArray());
+        mapStub.boolToReturn = false;
+        ReadableMapStub metaDataMap = new ReadableMapStub();
+        metaDataMap.hashMapToReturn = new HashMap<>();
+        mapStub.mapsForKeysToReturn.put(FidelSetupProperties.Options.META_DATA.jsName(), metaDataMap);
+        return mapStub;
+    }
+
+    private static ReadableMapStub consentTextMapWithAllValidSetupKeys() {
+        ReadableMapStub mapStub = new ReadableMapStub();
+        String[] keyJsNames = Arrays.stream(FidelSetupProperties.ConsentText.values())
+                .map(FidelSetupProperties.ConsentText::jsName)
+                .toArray(String[]::new);
+        mapStub.hasKeyStrings.addAll(Arrays.asList(keyJsNames));
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.ConsentText.COMPANY_NAME.jsName(),
+                "some test company name");
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.ConsentText.TERMS_AND_CONDITIONS_URL.jsName(),
+                "some test terms and conditions url");
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.ConsentText.PRIVACY_POLICY_URL.jsName(),
+                "some test privacy policy url");
+        mapStub.stringForKeyToReturn.put(FidelSetupProperties.ConsentText.PROGRAM_NAME.jsName(),
+                "some test program name");
+        return mapStub;
     }
 
-    public static ReadableMapStub mapWithExistingKey(String existingKey) {
-        return new ReadableMapStub(existingKey, "");
+    public static ReadableMapStub withEmptyValueForKey(FidelSetupProperties key) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        mapStub.stringForKeyToReturn.put(key.jsName(), "");
+        return mapStub;
     }
 
-    public static ReadableMapStub mapWithExistingKeyButNoValue(String existingKey) {
-        return new ReadableMapStub(existingKey, existingKey);
+    public static ReadableMapStub withoutKey(FidelSetupProperties key) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        mapStub.hasKeyStrings.remove(key.jsName());
+        mapStub.stringForKeyToReturn.remove(key.jsName());
+        mapStub.mapsForKeysToReturn.remove(key.jsName());
+        mapStub.readableArraysToReturn.remove(key.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub withoutOptionsKey(FidelSetupProperties.Options optionsKey) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        ReadableMapStub optionsMapStub = (ReadableMapStub) mapStub.getMap(FidelSetupProperties.OPTIONS.jsName());
+        assert optionsMapStub != null;
+        optionsMapStub.hasKeyStrings.remove(optionsKey.jsName());
+        optionsMapStub.stringForKeyToReturn.remove(optionsKey.jsName());
+        optionsMapStub.mapsForKeysToReturn.remove(optionsKey.jsName());
+        optionsMapStub.readableArraysToReturn.remove(optionsKey.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub withoutConsentTextKey(FidelSetupProperties.ConsentText consentTextKey) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        ReadableMapStub consentTextMapStub = (ReadableMapStub) mapStub
+                .getMap(FidelSetupProperties.CONSENT_TEXT.jsName());
+        assert consentTextMapStub != null;
+        consentTextMapStub.hasKeyStrings.remove(consentTextKey.jsName());
+        consentTextMapStub.stringForKeyToReturn.remove(consentTextKey.jsName());
+        consentTextMapStub.mapsForKeysToReturn.remove(consentTextKey.jsName());
+        consentTextMapStub.readableArraysToReturn.remove(consentTextKey.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub withNullValueForKey(FidelSetupProperties key) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        mapStub.isNullStrings.remove(key.jsName());
+        mapStub.stringForKeyToReturn.remove(key.jsName());
+        mapStub.mapsForKeysToReturn.remove(key.jsName());
+        mapStub.readableArraysToReturn.remove(key.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub withNullValueForOptionKey(FidelSetupProperties.Options optionKey) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        ReadableMapStub optionsMapStub = (ReadableMapStub) mapStub.getMap(FidelSetupProperties.OPTIONS.jsName());
+        assert optionsMapStub != null;
+        optionsMapStub.isNullStrings.add(optionKey.jsName());
+        optionsMapStub.stringForKeyToReturn.remove(optionKey.jsName());
+        optionsMapStub.mapsForKeysToReturn.remove(optionKey.jsName());
+        optionsMapStub.readableArraysToReturn.remove(optionKey.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub withNullValueForConsentTextKey(FidelSetupProperties.ConsentText consentTextKey) {
+        ReadableMapStub mapStub = ReadableMapStub.mapWithAllValidSetupKeys();
+        ReadableMapStub consentTextMapStub = (ReadableMapStub) mapStub
+                .getMap(FidelSetupProperties.CONSENT_TEXT.jsName());
+        assert consentTextMapStub != null;
+        consentTextMapStub.isNullStrings.add(consentTextKey.jsName());
+        consentTextMapStub.stringForKeyToReturn.remove(consentTextKey.jsName());
+        consentTextMapStub.mapsForKeysToReturn.remove(consentTextKey.jsName());
+        consentTextMapStub.readableArraysToReturn.remove(consentTextKey.jsName());
+        return mapStub;
+    }
+
+    public static ReadableMapStub cardConfigWithAllValidConfigKeys() {
+        ReadableMapStub mapStub = new ReadableMapStub();
+        String[] keyJsNames = Arrays.stream(CardVerificationConfigurationProperties.values())
+                .map(CardVerificationConfigurationProperties::jsName).toArray(String[]::new);
+        mapStub.hasKeyStrings.addAll(Arrays.asList(keyJsNames));
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.ID.jsName(), "123");
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.CONSENT_ID.jsName(), "456");
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.LAST_4_DIGITS.jsName(), "4567");
+        return mapStub;
+    }
+
+    public static ReadableMapStub cardConfigWithAllInValidConfigKeys() {
+        ReadableMapStub mapStub = new ReadableMapStub();
+        String[] keyJsNames = Arrays.stream(CardVerificationConfigurationProperties.values())
+                .map(CardVerificationConfigurationProperties::jsName).toArray(String[]::new);
+        mapStub.hasKeyStrings.addAll(Arrays.asList(keyJsNames));
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.ID.jsName(), null);
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.CONSENT_ID.jsName(), null);
+        mapStub.stringForKeyToReturn.put(CardVerificationConfigurationProperties.LAST_4_DIGITS.jsName(), null);
+        return mapStub;
+    }
+
+    public void putString(String key, String value) {
+        stringForKeyToReturn.put(key, value);
     }
 
     @Override
-    public boolean hasKey(@Nonnull String name) {
+    public boolean hasKey(@NonNull String name) {
         keyNamesCheckedFor.add(name);
-        return hasKeyString.equals(name);
+        return hasKeyStrings.contains(name);
     }
 
     @Override
-    public boolean isNull(@Nonnull String name) {
+    public boolean isNull(@NonNull String name) {
         keyNamesVerifiedNullFor.add(name);
-        return isNullString.equals(name);
+        return isNullStrings.contains(name);
     }
 
     @Override
-    public boolean getBoolean(@Nonnull String name) {
-        keyNamesAskedFor.add(name);
+    public boolean getBoolean(@NonNull String name) {
+        keyNamesAskedValueFor.add(name);
         return boolToReturn;
     }
 
     @Override
-    public double getDouble(@Nonnull String name) {
+    public double getDouble(@NonNull String name) {
         return 0;
     }
 
     @Override
-    public int getInt(@Nonnull String name) {
-        keyNamesAskedFor.add(name);
-        return intToReturn;
+    public int getInt(@NonNull String name) {
+        return -1;
     }
 
     @Nullable
     @Override
-    public String getString(@Nonnull String name) {
-        keyNamesAskedFor.add(name);
+    public String getString(@NonNull String name) {
+        keyNamesAskedValueFor.add(name);
         return stringForKeyToReturn.get(name);
     }
 
     @Nullable
     @Override
-    public ReadableArray getArray(@Nonnull String name) {
-        keyNamesAskedFor.add(name);
-        return readableArrayToReturn;
+    public ReadableArray getArray(@NonNull String name) {
+        keyNamesAskedValueFor.add(name);
+        return readableArraysToReturn.get(name);
     }
 
     @Nullable
     @Override
-    public ReadableMap getMap(@Nonnull String name) {
-        keyNamesAskedFor.add(name);
+    public ReadableMap getMap(@NonNull String name) {
+        keyNamesAskedValueFor.add(name);
         return mapsForKeysToReturn.get(name);
     }
 
-    @Nonnull
+    @NonNull
     @Override
-    public Dynamic getDynamic(@Nonnull String name) {
+    public Dynamic getDynamic(@NonNull String name) {
         return null;
     }
 
-    @Nonnull
+    @NonNull
     @Override
-    public ReadableType getType(@Nonnull String name) {
+    public ReadableType getType(@NonNull String name) {
         return null;
     }
 
-    @Nonnull
+    @NonNull
     @Override
     public ReadableMapKeySetIterator keySetIterator() {
         return null;
@@ -124,7 +259,7 @@ public class ReadableMapStub implements ReadableMap {
         return null;
     }
 
-    @Nonnull
+    @NonNull
     @Override
     public HashMap<String, Object> toHashMap() {
         return hashMapToReturn;

package/android/src/test/java/com/fidelreactlibrary/fakes/VerificationConfigurationAdapterStub.java

@@ -0,0 +1,13 @@
+package com.fidelreactlibrary.fakes;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.fidelapi.entities.CardVerificationConfiguration;
+import com.fidelreactlibrary.adapters.abstraction.VerificationConfigurationAdapter;
+
+public class VerificationConfigurationAdapterStub implements VerificationConfigurationAdapter {
+
+    @Override
+    public CardVerificationConfiguration adapt(ReadableMap data) {
+        return new CardVerificationConfiguration("", "", null);
+    }
+}

package/fidel-react-native.podspec

@@ -13,7 +13,7 @@ Pod::Spec.new do |s|
   s.platform     = :ios, "9.1"
 
   s.source       = { :git => "https://github.com/FidelLimited/rn-sdk.git", :tag => "v#{s.version}" }
-  s.source_files  = "ios/**/*.{h,m}"
+  s.source_files  = "ios/**/*.{h,m,swift}"
 
   s.dependency 'React'
   s.dependency 'Fidel'

package/index.js

@@ -1,26 +1,78 @@
-
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import { NativeEventEmitter, NativeModules } from "react-native";
 
 const { NativeFidelBridge } = NativeModules;
 
-class Fidel {
-    
-    static setup(params) { NativeFidelBridge.setup(params) }
-    static setOptions(params) { NativeFidelBridge.setOptions(params) }
-    static openForm(callback) {
-        if (this.eventSubscription != null) {
-            this.eventSubscription.remove();
-        }
-        this.eventSubscription = Fidel.emitter.addListener(
-            "CardLinkFailed",
-            error => callback(error, null)
+export default class Fidel {
+  static emitter = new NativeEventEmitter(NativeFidelBridge);
+  static Country = NativeFidelBridge.Country;
+  static CardScheme = NativeFidelBridge.CardScheme;
+  static ProgramType = NativeFidelBridge.ProgramType;
+  static ErrorType = NativeFidelBridge.ErrorType;
+  static EnrollmentErrorType = NativeFidelBridge.EnrollmentErrorType;
+  static VerificationErrorType = NativeFidelBridge.VerificationErrorType;
+  static CardVerificationChoice = NativeFidelBridge.CardVerificationChoice;
+
+  static setup(params, callback) {
+    if (this.eventSubscription != null) {
+      this.eventSubscription.remove();
+    }
+    const { onCardVerificationStarted } = params;
+    if (
+      onCardVerificationStarted != null &&
+      onCardVerificationStarted != undefined &&
+      typeof onCardVerificationStarted === "function"
+    ) {
+      if (this.onCardVerificationStartedEventSubscription != null) {
+        this.onCardVerificationStartedEventSubscription.remove();
+      }
+      this.onCardVerificationStartedEventSubscription =
+        Fidel.emitter.addListener(
+          "CardVerificationStarted",
+          (consentDetails) => {
+            onCardVerificationStarted(consentDetails);
+          }
         );
-        NativeFidelBridge.openForm(callback);
     }
-}
+    const { onCardVerificationChoiceSelected } = params;
+    if (
+      onCardVerificationChoiceSelected != null &&
+      onCardVerificationChoiceSelected != undefined &&
+      typeof onCardVerificationChoiceSelected === "function"
+    ) {
+      if (this.onCardVerificationChoiceSelectedEventSubscription != null) {
+        this.onCardVerificationChoiceSelectedEventSubscription.remove();
+      }
+      this.onCardVerificationChoiceSelectedEventSubscription =
+        Fidel.emitter.addListener(
+          "CardVerificationChoiceSelected",
+          (verificationChoice) => {
+            onCardVerificationChoiceSelected(verificationChoice);
+          }
+        );
+    }
+    if (
+      callback != null &&
+      callback != undefined &&
+      typeof callback === "function"
+    ) {
+      this.eventSubscription = Fidel.emitter.addListener(
+        "ResultAvailable",
+        (result) => callback(result)
+      );
+    }
+    NativeFidelBridge.setup(params);
+  }
 
-Fidel.emitter = new NativeEventEmitter(NativeFidelBridge);
-Fidel.Country = NativeFidelBridge.Country
-Fidel.CardScheme = NativeFidelBridge.CardScheme
+  static start() {
+    NativeFidelBridge.start();
+  }
+
+  static verifyCard(params) {
+    NativeFidelBridge.verifyCard(params);
+  }
+}
 
-module.exports = Fidel;
+export const ENROLLMENT_RESULT = NativeFidelBridge.ResultType.EnrollmentResult;
+export const ERROR = NativeFidelBridge.ResultType.Error;
+export const VERIFICATION_RESULT =
+  NativeFidelBridge.ResultType.VerificationResult;

package/ios/Adapters/CardSchemesAdapter.swift

@@ -0,0 +1,13 @@
+//
+//  CardSchemesAdapter.swift
+//  fidel-react-native
+//
+//  Created by Corneliu Chitanu on 08/12/21.
+//
+
+import Foundation
+import Fidel
+
+protocol CardSchemesAdapter {
+    func cardSchemes(from rawObject: NSObject) -> Set<CardScheme>
+}

package/ios/Adapters/ConsentDetailsAdapter.swift

@@ -0,0 +1,19 @@
+//
+//  ConsentDetailsAdapter.swift
+//  fidel-react-native
+//
+//  Created by Corneliu Chitanu on 07/06/23.
+//
+
+import Foundation
+import Fidel
+
+extension ConsentDetails {
+    var dictionary: [String: Any] {
+        return [
+            "cardId": cardID,
+            "consentId": consentID,
+            "programId": programID
+        ]
+    }
+}

package/ios/Adapters/EnrollmentResultAdapter.swift

@@ -0,0 +1,28 @@
+//
+//  EnrollmentResultAdapter.swift
+//  fidel-react-native
+//
+//  Created by Corneliu Chitanu on 09/12/21.
+//
+
+import Foundation
+import Fidel
+
+extension EnrollmentResult{
+    var dictionary: [String: Any] {
+        return [
+            "cardId": cardID,
+            "accountId": accountID,
+            "programId": programID,
+            "enrollmentDate": enrollmentDate.timeIntervalSince1970,
+            "cardScheme": scheme.constantKey,
+            "isLive": isLive,
+            "cardExpirationYear": cardExpirationYear,
+            "cardExpirationMonth": cardExpirationMonth,
+            "cardIssuingCountry": cardIssuingCountry.constantKey,
+            "cardFirstNumbers": cardFirstNumbers ?? NSNull(),
+            "cardLastNumbers": cardLastNumbers ?? NSNull(),
+            "metaData": metaData ?? NSNull(),
+        ]
+    }
+}

package/ios/Adapters/ErrorResultAdapter.swift

@@ -0,0 +1,71 @@
+//
+//  ErrorResultAdapter.swift
+//  fidel-react-native
+//
+//  Created by Corneliu Chitanu on 09/12/21.
+//
+
+import Foundation
+import Fidel
+
+extension FidelError {
+    var dictionary: [String: Any] {
+        var dictionaryToReturn: [String: Any] = [
+            "type": type.jsTypeValue,
+            "message": message,
+            "date": date.timeIntervalSince1970
+        ]
+        if let subtype = type.jsErrorSubtype {
+            dictionaryToReturn["subtype"] = subtype
+        }
+        return dictionaryToReturn
+    }
+}
+
+extension FidelErrorType {
+    var jsTypeValue: String {
+        switch self {
+        case .enrollmentError: return "enrollmentError"
+        case .verificationError: return "verificationError"
+        case .userCanceled: return "userCanceled"
+        case .sdkConfigurationError: return "sdkConfigurationError"
+        case .deviceNotSecure: return "deviceNotSecure"
+        @unknown default: return "unknown"
+        }
+    }
+    
+    var jsErrorSubtype: String? {
+        switch self {
+        case let .enrollmentError(enrollmentError):
+            switch enrollmentError {
+            case .cardAlreadyExists: return "cardAlreadyExists"
+            case .inexistentProgram: return "inexistentProgram"
+            case .invalidSDKKey: return "invalidSdkKey"
+            case .invalidProgramID: return "invalidProgramId"
+            case .unexpected: return "unexpected"
+            case .unauthorized: return "unauthorized"
+            case .issuerProcessingError: return "issuerProcessingError"
+            case .duplicateTransactionError: return "duplicateTransactionError"
+            case .insufficientFundsError: return "insufficientFundsError"
+            case .processingChargeError: return "processingChargeError"
+            case .cardDetailsError: return "cardDetailsError"
+            case .cardLimitExceededError: return "cardLimitExceededError"
+            @unknown default: return "unexpected"
+            }
+        case let .verificationError(verificationError):
+            switch verificationError {
+            case .cardAlreadyVerified: return "cardAlreadyVerified"
+            case .cardNotFound: return "cardNotFound"
+            case .verificationNotFound: return "verificationNotFound"
+            case .genericError: return "genericError"
+            case .maximumAttemptsReached: return "maximumAttemptsReached"
+            case .incorrectAmount, .incorrectAmountCode: return "incorrectAmount"
+            case .unauthorized: return "unauthorized"
+            case .unexpected: return "unexpected"
+            case .invalidSDKKey: return "invalidSdkKey"
+            @unknown default: return "unexpected"
+            }
+        default: return nil
+        }
+    }
+}

package/ios/{FLRNImageAdapter.h → Adapters/FLRNImageFromRNAdapter.h}

@@ -1,5 +1,5 @@
 //
-//  FLRNImageAdapter.h
+//  FLRNImageFromRNAdapter.h
 //  Fidel
 //
 //  Created by Corneliu on 24/03/2019.
@@ -7,9 +7,8 @@
 //
 
 #import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
 
-@protocol FLRNImageAdapter <NSObject>
+@interface FLRNImageFromRNAdapter : NSObject
 
 -(UIImage *)imageFromRawData:(id)rawImageData;
 

package/ios/Adapters/FidelSetupAdapter.swift

@@ -0,0 +1,89 @@
+//
+//  FidelSetupAdapter.swift
+//  fidel-react-native
+//
+//  Created by Corneliu Chitanu on 08/12/21.
+//
+
+import Foundation
+import Fidel
+
+class FidelSetupAdapter: NSObject {
+    
+    private let imageAdapter: FLRNImageFromRNAdapter
+    
+    init(imageAdapter: FLRNImageFromRNAdapter) {
+        self.imageAdapter = imageAdapter
+        super.init()
+    }
+    
+    func setup(with parameters: NSDictionary) {
+        guard let parameters = parameters as? [String: Any?] else {
+            return
+        }
+        if parameters.keys.contains(FidelSetupProperties.sdkKey.rawValue) {
+            Fidel.sdkKey = parameters[FidelSetupProperties.sdkKey.rawValue] as? String
+        }
+        if parameters.keys.contains(FidelSetupProperties.programID.rawValue) {
+            Fidel.programID = parameters[FidelSetupProperties.programID.rawValue] as? String
+        }
+        if parameters.keys.contains(FidelSetupProperties.programType.rawValue) {
+            let programTypeJSValue = parameters[FidelSetupProperties.programType.rawValue] as? String
+            Fidel.programType = ProgramType.programType(from: programTypeJSValue)
+        }
+        if parameters.keys.contains(FidelSetupProperties.options.rawValue),
+           let options = parameters[FidelSetupProperties.options.rawValue] as? [String: Any?] {
+            setOptions(options)
+        }
+        if parameters.keys.contains(FidelSetupProperties.consentText.rawValue),
+           let consentTextValues = parameters[FidelSetupProperties.consentText.rawValue] as? [String: Any?] {
+            setConsentTextValues(consentTextValues)
+        }
+    }
+    
+    func setOptions(_ options: [String: Any?]) {
+        if options.keys.contains(FidelSetupProperties.Options.bannerImage.rawValue),
+           let rawImageObject = options[FidelSetupProperties.Options.bannerImage.rawValue] as? NSObject {
+            Fidel.bannerImage = imageAdapter.image(fromRawData: rawImageObject)
+        }
+        if options.keys.contains(FidelSetupProperties.Options.allowedCountries.rawValue),
+           let countryJSKeys = options[FidelSetupProperties.Options.allowedCountries.rawValue] as? [String] {
+            Fidel.allowedCountries = Country.countriesSet(from: countryJSKeys)
+        }
+        if options.keys.contains(FidelSetupProperties.Options.defaultSelectedCountry.rawValue),
+           let countryJSKey = options[FidelSetupProperties.Options.defaultSelectedCountry.rawValue] as? String,
+           let defaultSelectedCountry = Country.country(from: countryJSKey) {
+            Fidel.defaultSelectedCountry = defaultSelectedCountry
+        }
+        if options.keys.contains(FidelSetupProperties.Options.supportedCardSchemes.rawValue),
+           let supportedCardSchemeJSKeys = options[FidelSetupProperties.Options.supportedCardSchemes.rawValue] as? [String] {
+            Fidel.supportedCardSchemes = CardScheme.cardSchemesSet(from: supportedCardSchemeJSKeys)
+        }
+        if options.keys.contains(FidelSetupProperties.Options.thirdPartyVerificationChoice.rawValue) {
+            Fidel.thirdPartyVerificationChoice = options[FidelSetupProperties.Options.thirdPartyVerificationChoice.rawValue] as? Bool ?? false
+        }
+        if options.keys.contains(FidelSetupProperties.Options.metaData.rawValue) {
+            Fidel.metaData = options[FidelSetupProperties.Options.metaData.rawValue] as? [String: Any]
+        }
+    }
+    
+    private func setConsentTextValues(_ consentTextValues: [String: Any?]) {
+        if consentTextValues.keys.contains(FidelSetupProperties.ConsentText.companyName.rawValue) {
+            Fidel.companyName = consentTextValues[FidelSetupProperties.ConsentText.companyName.rawValue] as? String
+        }
+        if consentTextValues.keys.contains(FidelSetupProperties.ConsentText.termsAndConditionsURL.rawValue) {
+            Fidel.termsAndConditionsURL = consentTextValues[FidelSetupProperties.ConsentText.termsAndConditionsURL.rawValue] as? String
+        }
+        if consentTextValues.keys.contains(FidelSetupProperties.ConsentText.privacyPolicyURL.rawValue) {
+            Fidel.privacyPolicyURL = consentTextValues[FidelSetupProperties.ConsentText.privacyPolicyURL.rawValue] as? String
+        }
+        if consentTextValues.keys.contains(FidelSetupProperties.ConsentText.programName.rawValue),
+           let programName = consentTextValues[FidelSetupProperties.ConsentText.programName.rawValue] as? String {
+            Fidel.programName = programName
+        }
+        if consentTextValues.keys.contains(FidelSetupProperties.ConsentText.deleteInstructions.rawValue),
+           let deleteInstructions = consentTextValues[FidelSetupProperties.ConsentText.deleteInstructions.rawValue] as? String {
+            Fidel.deleteInstructions = deleteInstructions
+        }
+    }
+}