judokit-react-native 3.4.8 → 3.5.0

package/JudoPay.tsx

@@ -13,7 +13,10 @@ export {
     JudoTransactionType,
     JudoTransactionMode,
     JudoPaymentMethod,
-    JudoCardNetwork
+    JudoCardNetwork,
+    ChallengeRequestIndicator,
+    JudoThreeDSButtonType,
+    ScaExemption
 } from './types/JudoTypes'
 
 export type {
@@ -25,7 +28,13 @@ export type {
     JudoTheme,
     JudoResponse,
     JudoConfiguration,
-    JudoAuthorization
+    JudoAuthorization,
+    NetworkTimeout,
+    JudoThreeDSButtonCustomization,
+    JudoThreeDSLabelCustomization,
+    JudoThreeDSTextBoxCustomization,
+    JudoThreeDSToolbarCustomization,
+    JudoThreeDSUIConfiguration
 } from './types/JudoTypes'
 
 export {
@@ -58,7 +67,6 @@ export type { JudoPBBAConfiguration } from './types/JudoPBBATypes'
 export { JudoPBBAButton }
 
 class JudoPay {
-
     //------------------------------------------------------------------
     // Private properties
     //------------------------------------------------------------------
@@ -114,7 +122,9 @@ class JudoPay {
      *
      * @returns an asynchronous boolean value that indicates if ApplePay is available.
      */
-    public isApplePayAvailableWithConfiguration(configuration: JudoConfiguration): Promise<boolean> {
+    public isApplePayAvailableWithConfiguration(
+        configuration: JudoConfiguration
+    ): Promise<boolean> {
         const params = this.generateJudoParameters(configuration)
         return NativeModules.RNJudo.isApplePayAvailableWithConfiguration(params)
     }
@@ -139,6 +149,18 @@ class JudoPay {
         return NativeModules.RNJudo.invokeTransaction(params)
     }
 
+    public async fetchTransactionDetails(
+        receiptId: string
+    ): Promise<JudoResponse> {
+        const params = {
+            authorization: this.generateAuthorizationParameters(),
+            sandboxed: this.isSandboxed,
+            receiptId
+        }
+
+        return NativeModules.RNJudo.fetchTransactionDetails(params)
+    }
+
     /**
      * A method for completing a payment/pre-auth transaction using a saved card token.
      *
@@ -155,8 +177,8 @@ class JudoPay {
         mode: JudoTransactionMode,
         configuration: JudoConfiguration,
         cardToken: string,
-        securityCode: string,
-        cardholderName: string,
+        securityCode: string | undefined | null,
+        cardholderName: string | undefined | null,
         cardScheme: string
     ): Promise<JudoResponse> {
         const params = this.generateTransactionModeParameters(
@@ -295,7 +317,10 @@ class JudoPay {
         }
     }
 
-    private readonly generateAuthorizationParameters = (): Record<string, any> => {
+    private readonly generateAuthorizationParameters = (): Record<
+        string,
+        any
+    > => {
         if (this.authorization.secret) {
             return {
                 token: this.authorization.token,

package/RNJudopay.podspec

@@ -15,7 +15,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/Classes/**/*.{h,m}"
   s.requires_arc = true
   s.dependency "React"
-  s.dependency "JudoKit-iOS", "3.1.8"
+  s.dependency "JudoKit-iOS", "3.1.10"
 
   s.test_spec 'RNJudoTests' do |test_spec|
     test_spec.source_files = 'ios/RNJudoTests/**/*.{h,m}'

package/android/build.gradle

@@ -101,7 +101,7 @@ dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.1.0'
 
-    implementation 'com.judopay:judokit-android:3.0.11'
+    implementation 'com.judopay:judokit-android:3.0.13'
 
     //JUnit 5
     testImplementation "org.junit.jupiter:junit-jupiter-api:$junit5_version"

package/android/src/main/java/com/reactlibrary/Extensions.kt

@@ -54,15 +54,15 @@ internal val ReadableMap.cardholderName: String?
 internal val ReadableMap.cardType: CardNetwork
     get() {
         val cardScheme = if (hasKey("cardScheme")) {
-            getString("cardScheme") ?: ""
+            getString("cardScheme")?.lowercase() ?: ""
         } else {
             ""
         }
 
-        return when (cardScheme.lowercase()) {
-            CARD_SCHEME_VISA -> CardNetwork.VISA
-            CARD_SCHEME_MASTERCARD -> CardNetwork.MASTERCARD
-            CARD_SCHEME_AMEX -> CardNetwork.AMEX
+        return when {
+            cardScheme.contains(CARD_SCHEME_VISA)  -> CardNetwork.VISA
+            cardScheme.contains(CARD_SCHEME_MASTERCARD) -> CardNetwork.MASTERCARD
+            cardScheme.contains(CARD_SCHEME_AMEX) -> CardNetwork.AMEX
             else -> CardNetwork.OTHER
         }
     }
@@ -70,6 +70,9 @@ internal val ReadableMap.cardType: CardNetwork
 internal val ReadableMap.judoId: String?
     get() = configuration?.getString("judoId")
 
+internal val ReadableMap.receiptId: String?
+    get() = getString("receiptId")
+
 internal val ReadableMap.token: String?
     get() = authorization?.getString("token")
 
@@ -100,6 +103,9 @@ internal val ReadableMap.paymentReference: String?
 internal val ReadableMap.isInitialRecurringPayment: Boolean?
     get() = configuration?.getBoolean("isInitialRecurringPayment")
 
+internal val ReadableMap.isDelayedAuthorisation: Boolean?
+    get() = configuration?.getBoolean("isDelayedAuthorisation")
+
 internal val ReadableMap.networkTimeout: ReadableMap?
     get() {
         if (configuration.hasKey("networkTimeout")) {
@@ -276,6 +282,182 @@ internal val ReadableMap.uiConfiguration: ReadableMap?
         return null
     }
 
+internal val ReadableMap.threeDSUIConfiguration: ReadableMap?
+    get() {
+        if (uiConfiguration.hasKey("threeDSUIConfiguration")) {
+            return uiConfiguration?.getMap("threeDSUIConfiguration")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUITextBoxCustomization: ReadableMap?
+    get() {
+        if (threeDSUIConfiguration.hasKey("textBoxCustomization")) {
+            return threeDSUIConfiguration?.getMap("textBoxCustomization")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUIButtonCustomizations: ReadableMap?
+    get() {
+        if (threeDSUIConfiguration.hasKey("buttonCustomizations")) {
+            return threeDSUIConfiguration?.getMap("buttonCustomizations")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUISubmitButtonCustomization: ReadableMap?
+    get() {
+        if (threeDSUIButtonCustomizations.hasKey("SUBMIT")) {
+            return threeDSUIButtonCustomizations?.getMap("SUBMIT")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUIContinueButtonCustomization: ReadableMap?
+    get() {
+        if (threeDSUIButtonCustomizations.hasKey("CONTINUE")) {
+            return threeDSUIButtonCustomizations?.getMap("CONTINUE")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUINextButtonCustomization: ReadableMap?
+    get() {
+        if (threeDSUIButtonCustomizations.hasKey("NEXT")) {
+            return threeDSUIButtonCustomizations?.getMap("NEXT")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUICancelButtonCustomization: ReadableMap?
+    get() {
+        if (threeDSUIButtonCustomizations.hasKey("CANCEL")) {
+            return threeDSUIButtonCustomizations?.getMap("CANCEL")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUIResendButtonCustomization: ReadableMap?
+    get() {
+        if (threeDSUIButtonCustomizations.hasKey("RESEND")) {
+            return threeDSUIButtonCustomizations?.getMap("RESEND")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUIToolbarCustomization: ReadableMap?
+    get() {
+        if (threeDSUIConfiguration.hasKey("toolbarCustomization")) {
+            return threeDSUIConfiguration?.getMap("toolbarCustomization")
+        }
+        return null
+    }
+
+internal val ReadableMap.threeDSUILabelCustomization: ReadableMap?
+    get() {
+        if (threeDSUIConfiguration.hasKey("labelCustomization")) {
+            return threeDSUIConfiguration?.getMap("labelCustomization")
+        }
+        return null
+    }
+
+internal val ReadableMap.textFontName: String?
+    get() {
+        if (hasKey("textFontName")) {
+            return getString("textFontName")
+        }
+        return null
+    }
+
+internal val ReadableMap.textColor: String?
+    get() {
+        if (hasKey("textColor")) {
+            return getString("textColor")
+        }
+        return null
+    }
+
+internal val ReadableMap.backgroundColor: String?
+    get() {
+        if (hasKey("backgroundColor")) {
+            return getString("backgroundColor")
+        }
+        return null
+    }
+
+internal val ReadableMap.headerText: String?
+    get() {
+        if (hasKey("headerText")) {
+            return getString("headerText")
+        }
+        return null
+    }
+
+internal val ReadableMap.buttonText: String?
+    get() {
+        if (hasKey("buttonText")) {
+            return getString("buttonText")
+        }
+        return null
+    }
+
+internal val ReadableMap.headingTextFontName: String?
+    get() {
+        if (hasKey("headingTextFontName")) {
+            return getString("headingTextFontName")
+        }
+        return null
+    }
+
+internal val ReadableMap.headingTextColor: String?
+    get() {
+        if (hasKey("headingTextColor")) {
+            return getString("headingTextColor")
+        }
+        return null
+    }
+
+internal val ReadableMap.borderColor: String?
+    get() {
+        if (hasKey("borderColor")) {
+            return getString("borderColor")
+        }
+        return null
+    }
+
+internal val ReadableMap.textFontSize: Int?
+    get() {
+        if (hasKey("textFontSize")) {
+            return getInt("textFontSize")
+        }
+        return null
+    }
+
+internal val ReadableMap.cornerRadius: Int?
+    get() {
+        if (hasKey("cornerRadius")) {
+            return getInt("cornerRadius")
+        }
+        return null
+    }
+
+internal val ReadableMap.headingTextFontSize: Int?
+    get() {
+        if (hasKey("headingTextFontSize")) {
+            return getInt("headingTextFontSize")
+        }
+        return null
+    }
+
+internal val ReadableMap.borderWidth: Int?
+    get() {
+        if (hasKey("borderWidth")) {
+            return getInt("borderWidth")
+        }
+        return null
+    }
+
 internal val ReadableMap.isAVSEnabled: Boolean?
     get() = uiConfiguration?.getBoolean("isAVSEnabled")
 

package/android/src/main/java/com/reactlibrary/Helpers.kt

@@ -5,6 +5,11 @@ import android.os.Bundle
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
+import com.judopay.judo3ds2.customization.ButtonCustomization
+import com.judopay.judo3ds2.customization.LabelCustomization
+import com.judopay.judo3ds2.customization.TextBoxCustomization
+import com.judopay.judo3ds2.customization.ToolbarCustomization
+import com.judopay.judo3ds2.customization.UiCustomization
 import com.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.model.Authorization
 import com.judopay.judokit.android.api.model.BasicAuthorization
@@ -87,6 +92,7 @@ internal fun getMappedResult(result: JudoResult?): WritableMap {
     cardDetailsMap.putString("cardCountry", result?.cardDetails?.country)
     cardDetailsMap.putString("cardFunding", result?.cardDetails?.funding)
     cardDetailsMap.putString("cardScheme", result?.cardDetails?.scheme)
+    cardDetailsMap.putString("cardHolderName", result?.cardDetails?.cardHolderName)
 
     map.putMap("cardDetails", cardDetailsMap)
 
@@ -99,6 +105,27 @@ internal fun getMappedResult(result: JudoResult?): WritableMap {
     return map
 }
 
+internal fun getJudoConfigurationForApiService(options: ReadableMap): Judo {
+    val authorization = getAuthorization(options)
+
+    val amount = Amount.Builder()
+        .setAmount("0.00")
+        .setCurrency(Currency.GBP)
+        .build()
+
+    val reference = Reference.Builder()
+        .setConsumerReference("reference")
+        .build()
+
+    return Judo.Builder(PaymentWidgetType.CARD_PAYMENT)
+        .setIsSandboxed(options.isSandboxed)
+        .setJudoId("000000")
+        .setAuthorization(authorization)
+        .setAmount(amount)
+        .setReference(reference)
+        .build()
+}
+
 internal fun getJudoConfiguration(type: PaymentWidgetType, options: ReadableMap): Judo {
     val authorization = getAuthorization(options)
     val amount = getAmount(options)
@@ -127,6 +154,7 @@ internal fun getJudoConfiguration(type: PaymentWidgetType, options: ReadableMap)
         .setGooglePayConfiguration(googlePayConfiguration)
         .setPBBAConfiguration(pbbaConfiguration)
         .setInitialRecurringPayment(options.isInitialRecurringPayment)
+        .setDelayedAuthorisation(options.isDelayedAuthorisation)
         .setNetworkTimeout(timeouts)
         .setChallengeRequestIndicator(challengeRequestIndicator)
         .setScaExemption(scaExemption)
@@ -331,12 +359,110 @@ internal fun getUIConfiguration(options: ReadableMap): UiConfiguration? {
             .setShouldPaymentButtonDisplayAmount(options.shouldPaymentButtonDisplayAmount)
             .setShouldPaymentMethodsVerifySecurityCode(options.shouldPaymentMethodsVerifySecurityCode)
             .setShouldAskForBillingInformation(options.shouldAskForBillingInformation)
+            .setThreeDSUiCustomization(getThreeDSUiCustomization(options))
             .build()
     } else {
         null
     }
 }
 
+internal fun getThreeDSUiCustomization(options: ReadableMap): UiCustomization? {
+    return if (options.threeDSUIConfiguration != null) {
+
+        val uiCustomization = UiCustomization()
+
+        options.threeDSUIToolbarCustomization?.let {
+            uiCustomization.setToolbarCustomization(ToolbarCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setBackgroundColor(it.backgroundColor)
+                setHeaderText(it.headerText)
+                setButtonText(it.buttonText)
+            })
+        }
+
+        options.threeDSUILabelCustomization?.let {
+            uiCustomization.setLabelCustomization(LabelCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setHeadingTextFontName(it.headingTextFontName)
+                setHeadingTextColor(it.headingTextColor)
+                setHeadingTextFontSize(it.headingTextFontSize)
+            })
+        }
+
+        options.threeDSUITextBoxCustomization?.let {
+            uiCustomization.setTextBoxCustomization(TextBoxCustomization().apply {
+                setTextFontName(it.textFontName)
+                setTextColor(it.textColor)
+                setTextFontSize(it.textFontSize)
+                setBorderWidth(it.borderWidth)
+                setBorderColor(it.borderColor)
+                setCornerRadius(it.cornerRadius)
+            })
+        }
+
+        if (options.threeDSUIButtonCustomizations != null) {
+
+            options.threeDSUISubmitButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.SUBMIT)
+            }
+
+            options.threeDSUINextButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.NEXT)
+            }
+
+            options.threeDSUIContinueButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.CONTINUE)
+            }
+
+            options.threeDSUICancelButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.CANCEL)
+            }
+
+            options.threeDSUIResendButtonCustomization?.let {
+                uiCustomization.setButtonCustomization(ButtonCustomization().apply {
+                    setTextFontName(it.textFontName)
+                    setTextColor(it.textColor)
+                    setTextFontSize(it.textFontSize)
+                    setBackgroundColor(it.backgroundColor)
+                    setCornerRadius(it.cornerRadius)
+                }, UiCustomization.ButtonType.RESEND)
+            }
+        }
+
+        uiCustomization
+    } else {
+        null
+    }
+}
+
 internal fun getPrimaryAccountDetails(options: ReadableMap): PrimaryAccountDetails? {
     return if (options.primaryAccountDetails != null) {
         PrimaryAccountDetails.Builder()

package/android/src/main/java/com/reactlibrary/JudoReactNativeModule.kt

@@ -9,6 +9,7 @@ import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.facebook.react.bridge.*
 import com.judopay.judokit.android.Judo
 import com.judopay.judokit.android.api.JudoApiService
+import com.judopay.judokit.android.api.error.toJudoError
 import com.judopay.judokit.android.api.factory.JudoApiServiceFactory
 import com.judopay.judokit.android.api.model.response.JudoApiCallResult
 import com.judopay.judokit.android.api.model.response.Receipt
@@ -31,6 +32,7 @@ import retrofit2.Response
 
 const val JUDO_PAYMENT_WIDGET_REQUEST_CODE = 65520
 const val JUDO_PROMISE_REJECTION_CODE = "JUDO_ERROR"
+const val REQUEST_FAILED_MESSAGE = "The request was unsuccessful."
 
 class JudoReactNativeModule internal constructor(val context: ReactApplicationContext) :
     ReactContextBaseJavaModule(context), CardTransactionManagerResultListener {
@@ -114,7 +116,6 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
             val manager = CardTransactionManager.getInstance(activity)
 
             val judo = getTokenTransactionConfiguration(options)
-
             val cardToken = options.cardToken
 
             if (cardToken == null) {
@@ -122,6 +123,8 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
                 return
             }
 
+            manager.configureWith(judo)
+
             val details = TransactionDetails.Builder()
                 .setCardHolderName(options.cardholderName)
                 .setSecurityNumber(options.securityCode)
@@ -150,6 +153,56 @@ class JudoReactNativeModule internal constructor(val context: ReactApplicationCo
         }
     }
 
+    @ReactMethod
+    fun fetchTransactionDetails(options: ReadableMap, promise: Promise) {
+        try {
+            val judo = getJudoConfigurationForApiService(options)
+            val receiptId = options.receiptId ?: ""
+
+            val service = JudoApiServiceFactory.createApiService(context, judo)
+
+            val fetchTransactionDetailsCallback = object : Callback<JudoApiCallResult<Receipt>> {
+                override fun onResponse(
+                    call: Call<JudoApiCallResult<Receipt>>,
+                    response: Response<JudoApiCallResult<Receipt>>
+                ) {
+                    when (val result = response.body()) {
+                        is JudoApiCallResult.Success -> {
+                            val receipt = result.data
+                            if (receipt != null) {
+                                val judoResult = receipt.toJudoResult()
+                                promise.resolve(getMappedResult(judoResult))
+                            } else {
+                                promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                            }
+                        }
+                        is JudoApiCallResult.Failure -> {
+                            val message = result.error?.message ?: REQUEST_FAILED_MESSAGE
+                            promise.reject(JUDO_PROMISE_REJECTION_CODE, message)
+                        }
+                        else -> {
+                            promise.reject(JUDO_PROMISE_REJECTION_CODE, REQUEST_FAILED_MESSAGE)
+                        }
+                    }
+                }
+
+                override fun onFailure(
+                    call: Call<JudoApiCallResult<Receipt>>,
+                    throwable: Throwable
+                ) {
+                    promise.reject(JUDO_PROMISE_REJECTION_CODE, throwable.localizedMessage, throwable)
+                }
+            }
+
+            service
+                .fetchTransactionWithReceiptId(receiptId)
+                .enqueue(fetchTransactionDetailsCallback)
+
+        } catch (error: Exception) {
+            promise.reject(JUDO_PROMISE_REJECTION_CODE, error.localizedMessage, error)
+        }
+    }
+
     private fun ensureIsSubscribedToCardTransactionResults() {
         if (isSubscribedToCardTransactionResults) {
             return

package/ios/Classes/RNJudo.m

@@ -128,13 +128,19 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
                  properties:(NSDictionary *)properties
                  fetchTransactionDetailsWithResolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject) {
+    @try {
+        self.apiService = [RNWrappers apiServiceFromProperties:properties];
+        self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
 
-    self.apiService = [RNWrappers apiServiceFromProperties:properties];
-    self.completionBlock = [self completionBlockWithResolve:resolve andReject:reject];
-
-    NSString *receiptId = [RNWrappers receiptIdFromProperties:properties];
+        NSString *receiptId = [RNWrappers receiptIdFromProperties:properties];
 
-    [self.apiService fetchTransactionWithReceiptId:receiptId completion:self.completionBlock];
+        [self.apiService fetchTransactionWithReceiptId:receiptId completion:self.completionBlock];
+    } @catch (NSException *exception) {
+        NSError *error = [[NSError alloc] initWithDomain:RNJudoErrorDomain
+                                                    code:0
+                                                userInfo:exception.userInfo];
+        reject(kJudoPromiseRejectionCode, exception.reason, error);
+    }
 }
 
 //----------------------------------------------
@@ -204,7 +210,17 @@ RCT_REMAP_METHOD(fetchTransactionDetails,
                 message = description;
             }
             
-            reject(kJudoPromiseRejectionCode, message, error);
+            // TODO: RCTJSErrorFromCodeMessageAndNSError expects an NSError instane in userInfo[NSUnderlyingErrorKey]
+            // which in case of a 3DS SDK error is a NSString ('JP3DSSDKRuntimeException') - so it crashes
+            // ! this should be fixed in JudoKit-iOS, and the folowing workaround removed ASAP
+            NSMutableDictionary *userInfo = [NSMutableDictionary dictionaryWithDictionary:error.userInfo];
+            [userInfo removeObjectForKey:NSUnderlyingErrorKey];
+            NSError *myError = [[NSError alloc] initWithDomain:error.domain
+                                                          code:error.code
+                                                      userInfo:[NSDictionary dictionaryWithDictionary:userInfo]];
+            
+            
+            reject(kJudoPromiseRejectionCode, message, myError);
         } else {
             NSDictionary *mappedResponse = [RNWrappers dictionaryFromResponse:response];
             resolve(mappedResponse);

package/ios/Classes/Wrappers/RNWrappers.m

@@ -28,6 +28,7 @@
 #import "RNTypes.h"
 #import "NSDictionary+JudoConvert.h"
 #import "UIColor+RNAdditions.h"
+#import <Judo3DS2_iOS/Judo3DS2_iOS.h>
 
 static NSString *const kCardSchemeVISA = @"visa";
 static NSString *const kCardSchemeMasterCard = @"mastercard";
@@ -129,6 +130,7 @@ static NSString *const kCardSchemeAMEX = @"amex";
 
     NSString *judoId = [configurationDict stringForKey:@"judoId"];
     NSNumber *isInitialRecurringPayment = [configurationDict optionalBoolForKey:@"isInitialRecurringPayment"];
+    NSNumber *isDelayedAuthorisation = [configurationDict optionalBoolForKey:@"isDelayedAuthorisation"];
 
     JPAmount *amount = [RNWrappers amountFromConfiguration:configurationDict];
     JPReference *reference = [RNWrappers referenceFromConfiguration:configurationDict];
@@ -137,7 +139,14 @@ static NSString *const kCardSchemeAMEX = @"amex";
                                                                       amount:amount
                                                                    reference:reference];
 
-    configuration.isInitialRecurringPayment = isInitialRecurringPayment;
+    if (isInitialRecurringPayment) {
+        configuration.isInitialRecurringPayment = isInitialRecurringPayment.boolValue;
+    }
+
+    if (isDelayedAuthorisation) {
+        configuration.isDelayedAuthorisation = isDelayedAuthorisation.boolValue;
+    }
+
     configuration.uiConfiguration = [RNWrappers uiConfigurationFromConfiguration:configurationDict];
     configuration.supportedCardNetworks = [RNWrappers cardNetworksFromConfiguration:configurationDict];
     configuration.primaryAccountDetails = [RNWrappers accountDetailsFromConfiguration:configurationDict];
@@ -246,15 +255,15 @@ static NSString *const kCardSchemeAMEX = @"amex";
 + (JPCardNetworkType)cardTypeFromProperties:(NSDictionary *)properties {
     NSString *cardScheme = [properties optionalStringForKey:@"cardScheme"].lowercaseString;
     
-    if ([kCardSchemeVISA isEqualToString:cardScheme]) {
+    if ([cardScheme containsString:kCardSchemeVISA]) {
         return JPCardNetworkTypeVisa;
     }
     
-    if ([kCardSchemeMasterCard isEqualToString:cardScheme]) {
+    if ([cardScheme containsString:kCardSchemeMasterCard]) {
         return JPCardNetworkTypeMasterCard;
     }
     
-    if ([kCardSchemeAMEX isEqualToString:cardScheme]) {
+    if ([cardScheme containsString:kCardSchemeAMEX]) {
         return JPCardNetworkTypeAMEX;
     }
     
@@ -342,26 +351,334 @@ static NSString *const kCardSchemeAMEX = @"amex";
         return uiConfiguration;
     }
 
-    NSNumber *isAVSEnabled = [dictionary boolForKey:@"isAVSEnabled"];
-    NSNumber *shouldDisplayAmount = [dictionary boolForKey:@"shouldPaymentMethodsDisplayAmount"];
-    NSNumber *isPayButtonAmountVisible = [dictionary boolForKey:@"shouldPaymentButtonDisplayAmount"];
-    NSNumber *isSecureCodeCheckEnabled = [dictionary boolForKey:@"shouldPaymentMethodsVerifySecurityCode"];
+    NSNumber *isAVSEnabled = [dictionary optionalBoolForKey:@"isAVSEnabled"];
+    NSNumber *shouldDisplayAmount = [dictionary optionalBoolForKey:@"shouldPaymentMethodsDisplayAmount"];
+    NSNumber *isPayButtonAmountVisible = [dictionary optionalBoolForKey:@"shouldPaymentButtonDisplayAmount"];
+    NSNumber *isSecureCodeCheckEnabled = [dictionary optionalBoolForKey:@"shouldPaymentMethodsVerifySecurityCode"];
     NSNumber *shouldAskForBillingInformation = [dictionary optionalBoolForKey:@"shouldAskForBillingInformation"];
     
-    uiConfiguration.isAVSEnabled = isAVSEnabled.boolValue;
-    uiConfiguration.shouldPaymentMethodsDisplayAmount = shouldDisplayAmount.boolValue;
-    uiConfiguration.shouldPaymentButtonDisplayAmount = isPayButtonAmountVisible.boolValue;
-    uiConfiguration.shouldPaymentMethodsVerifySecurityCode = isSecureCodeCheckEnabled.boolValue;
+    if (isAVSEnabled) {
+        uiConfiguration.isAVSEnabled = isAVSEnabled.boolValue;
+    }
+
+    if (shouldDisplayAmount) {
+        uiConfiguration.shouldPaymentMethodsDisplayAmount = shouldDisplayAmount.boolValue;
+    }
+
+    if (isPayButtonAmountVisible) {
+        uiConfiguration.shouldPaymentButtonDisplayAmount = isPayButtonAmountVisible.boolValue;
+    }
+
+    if (isSecureCodeCheckEnabled) {
+        uiConfiguration.shouldPaymentMethodsVerifySecurityCode = isSecureCodeCheckEnabled.boolValue;
+    }
     
     if (shouldAskForBillingInformation) {
         uiConfiguration.shouldAskForBillingInformation = shouldAskForBillingInformation.boolValue;
     }
     
     uiConfiguration.theme = [self themeFromUIConfiguration:dictionary];
+    uiConfiguration.threeDSUICustomization = [self threeDSUICustomization:dictionary];
 
     return uiConfiguration;
 }
 
++ (JP3DSUICustomization *)threeDSUICustomization:(NSDictionary *)uiCustomization {
+    NSDictionary *dictionary = [uiCustomization optionalDictionaryForKey:@"threeDSUIConfiguration"];
+
+    if (!dictionary) {
+        return nil;
+    }
+
+    NSDictionary *buttonCustomizations = [dictionary optionalDictionaryForKey:@"buttonCustomizations"];
+    NSDictionary *toolbarCustomizations = [dictionary optionalDictionaryForKey:@"toolbarCustomization"];
+    NSDictionary *labelCustomizations = [dictionary optionalDictionaryForKey:@"labelCustomization"];
+    NSDictionary *textBoxCustomizations = [dictionary optionalDictionaryForKey:@"textBoxCustomization"];
+
+    JP3DSUICustomization *customization = [JP3DSUICustomization new];
+
+    if (buttonCustomizations) {
+        NSDictionary *submitButtonCustomization = [buttonCustomizations optionalDictionaryForKey:@"SUBMIT"];
+        NSDictionary *continueButtonCustomization = [buttonCustomizations optionalDictionaryForKey:@"CONTINUE"];
+        NSDictionary *nextButtonCustomization = [buttonCustomizations optionalDictionaryForKey:@"NEXT"];
+        NSDictionary *cancelButtonCustomization = [buttonCustomizations optionalDictionaryForKey:@"CANCEL"];
+        NSDictionary *resendButtonCustomization = [buttonCustomizations optionalDictionaryForKey:@"RESEND"];
+
+        if (submitButtonCustomization) {
+            JP3DSButtonCustomization *submitCustomization = [JP3DSButtonCustomization new];
+
+            NSString *textFontName = [submitButtonCustomization optionalStringForKey:@"textFontName"];
+            NSString *textColor = [submitButtonCustomization optionalStringForKey:@"textColor"];
+            NSString *backgroundColor = [submitButtonCustomization optionalStringForKey:@"backgroundColor"];
+            NSNumber *cornerRadius = [submitButtonCustomization optionalNumberForKey:@"cornerRadius"];
+            NSNumber *textFontSize = [submitButtonCustomization optionalNumberForKey:@"textFontSize"];
+
+            if (textFontName) {
+                [submitCustomization setTextFontName:textFontName];
+            }
+
+            if (textColor) {
+                [submitCustomization setTextColor:textColor];
+            }
+
+            if (backgroundColor) {
+                [submitCustomization setBackgroundColor:backgroundColor];
+            }
+
+            if (cornerRadius) {
+                [submitCustomization setCornerRadius:cornerRadius.integerValue];
+            }
+
+            if (textFontSize) {
+                [submitCustomization setTextFontSize:textFontSize.integerValue];
+            }
+
+            [customization setButtonCustomization:submitCustomization ofType:JP3DSButtonTypeSubmit];
+        }
+
+        if (continueButtonCustomization) {
+            JP3DSButtonCustomization *continueCustomization = [JP3DSButtonCustomization new];
+
+            NSString *textFontName = [continueButtonCustomization optionalStringForKey:@"textFontName"];
+            NSString *textColor = [continueButtonCustomization optionalStringForKey:@"textColor"];
+            NSString *backgroundColor = [continueButtonCustomization optionalStringForKey:@"backgroundColor"];
+            NSNumber *cornerRadius = [continueButtonCustomization optionalNumberForKey:@"cornerRadius"];
+            NSNumber *textFontSize = [continueButtonCustomization optionalNumberForKey:@"textFontSize"];
+
+            if (textFontName) {
+                [continueCustomization setTextFontName:textFontName];
+            }
+
+            if (textColor) {
+                [continueCustomization setTextColor:textColor];
+            }
+
+            if (backgroundColor) {
+                [continueCustomization setBackgroundColor:backgroundColor];
+            }
+
+            if (cornerRadius) {
+                [continueCustomization setCornerRadius:cornerRadius.integerValue];
+            }
+
+            if (textFontSize) {
+                [continueCustomization setTextFontSize:textFontSize.integerValue];
+            }
+
+            [customization setButtonCustomization:continueCustomization ofType:JP3DSButtonTypeContinue];
+        }
+
+        if (nextButtonCustomization) {
+            JP3DSButtonCustomization *nextCustomization = [JP3DSButtonCustomization new];
+
+            NSString *textFontName = [nextButtonCustomization optionalStringForKey:@"textFontName"];
+            NSString *textColor = [nextButtonCustomization optionalStringForKey:@"textColor"];
+            NSString *backgroundColor = [nextButtonCustomization optionalStringForKey:@"backgroundColor"];
+            NSNumber *cornerRadius = [nextButtonCustomization optionalNumberForKey:@"cornerRadius"];
+            NSNumber *textFontSize = [nextButtonCustomization optionalNumberForKey:@"textFontSize"];
+
+            if (textFontName) {
+                [nextCustomization setTextFontName:textFontName];
+            }
+
+            if (textColor) {
+                [nextCustomization setTextColor:textColor];
+            }
+
+            if (backgroundColor) {
+                [nextCustomization setBackgroundColor:backgroundColor];
+            }
+
+            if (cornerRadius) {
+                [nextCustomization setCornerRadius:cornerRadius.integerValue];
+            }
+
+            if (textFontSize) {
+                [nextCustomization setTextFontSize:textFontSize.integerValue];
+            }
+
+            [customization setButtonCustomization:nextCustomization ofType:JP3DSButtonTypeNext];
+        }
+
+        if (cancelButtonCustomization) {
+            JP3DSButtonCustomization *cancelCustomization = [JP3DSButtonCustomization new];
+
+            NSString *textFontName = [cancelButtonCustomization optionalStringForKey:@"textFontName"];
+            NSString *textColor = [cancelButtonCustomization optionalStringForKey:@"textColor"];
+            NSString *backgroundColor = [cancelButtonCustomization optionalStringForKey:@"backgroundColor"];
+            NSNumber *cornerRadius = [cancelButtonCustomization optionalNumberForKey:@"cornerRadius"];
+            NSNumber *textFontSize = [cancelButtonCustomization optionalNumberForKey:@"textFontSize"];
+
+            if (textFontName) {
+                [cancelCustomization setTextFontName:textFontName];
+            }
+
+            if (textColor) {
+                [cancelCustomization setTextColor:textColor];
+            }
+
+            if (backgroundColor) {
+                [cancelCustomization setBackgroundColor:backgroundColor];
+            }
+
+            if (cornerRadius) {
+                [cancelCustomization setCornerRadius:cornerRadius.integerValue];
+            }
+
+            if (textFontSize) {
+                [cancelCustomization setTextFontSize:textFontSize.integerValue];
+            }
+
+            [customization setButtonCustomization:cancelCustomization ofType:JP3DSButtonTypeCancel];
+        }
+
+        if (resendButtonCustomization) {
+            JP3DSButtonCustomization *resendCustomization = [JP3DSButtonCustomization new];
+
+            NSString *textFontName = [resendButtonCustomization optionalStringForKey:@"textFontName"];
+            NSString *textColor = [resendButtonCustomization optionalStringForKey:@"textColor"];
+            NSString *backgroundColor = [resendButtonCustomization optionalStringForKey:@"backgroundColor"];
+            NSNumber *cornerRadius = [resendButtonCustomization optionalNumberForKey:@"cornerRadius"];
+            NSNumber *textFontSize = [resendButtonCustomization optionalNumberForKey:@"textFontSize"];
+
+            if (textFontName) {
+                [resendCustomization setTextFontName:textFontName];
+            }
+
+            if (textColor) {
+                [resendCustomization setTextColor:textColor];
+            }
+
+            if (backgroundColor) {
+                [resendCustomization setBackgroundColor:backgroundColor];
+            }
+
+            if (cornerRadius) {
+                [resendCustomization setCornerRadius:cornerRadius.integerValue];
+            }
+
+            if (textFontSize) {
+                [resendCustomization setTextFontSize:textFontSize.integerValue];
+            }
+
+            [customization setButtonCustomization:resendCustomization ofType:JP3DSButtonTypeResend];
+        }
+    }
+
+    if (labelCustomizations) {
+        JP3DSLabelCustomization *labelCustomization = [JP3DSLabelCustomization new];
+
+        NSString *textFontName = [labelCustomizations optionalStringForKey:@"textFontName"];
+        NSString *textColor = [labelCustomizations optionalStringForKey:@"textColor"];
+        NSString *headingTextFontName = [labelCustomizations optionalStringForKey:@"headingTextFontName"];
+        NSString *headingTextColor = [labelCustomizations optionalStringForKey:@"headingTextColor"];
+        NSNumber *headingTextFontSize = [labelCustomizations optionalNumberForKey:@"headingTextFontSize"];
+        NSNumber *textFontSize = [labelCustomizations optionalNumberForKey:@"textFontSize"];
+
+        if (textFontName) {
+            [labelCustomization setTextFontName:textFontName];
+        }
+
+        if (textColor) {
+            [labelCustomization setTextColor:textColor];
+        }
+
+        if (headingTextFontName) {
+            [labelCustomization setHeadingTextFontName:headingTextFontName];
+        }
+
+        if (headingTextColor) {
+            [labelCustomization setHeadingTextColor:headingTextColor];
+        }
+
+        if (headingTextFontSize) {
+            [labelCustomization setHeadingTextFontSize:headingTextFontSize.integerValue];
+        }
+
+        if (textFontSize) {
+            [labelCustomization setTextFontSize:textFontSize.integerValue];
+        }
+
+        [customization setLabelCustomization:labelCustomization];
+    }
+
+    if (toolbarCustomizations) {
+        JP3DSToolbarCustomization *toolbarCustomization = [JP3DSToolbarCustomization new];
+
+        NSNumber *textFontSize = [toolbarCustomizations optionalNumberForKey:@"textFontSize"];
+        NSString *textFontName = [toolbarCustomizations optionalStringForKey:@"textFontName"];
+        NSString *textColor = [toolbarCustomizations optionalStringForKey:@"textColor"];
+        NSString *backgroundColor = [toolbarCustomizations optionalStringForKey:@"backgroundColor"];
+        NSString *headerText = [toolbarCustomizations optionalStringForKey:@"headerText"];
+        NSString *buttonText = [toolbarCustomizations optionalStringForKey:@"buttonText"];
+
+        if (textFontName) {
+            [toolbarCustomization setTextFontName:textFontName];
+        }
+
+        if (textColor) {
+            [toolbarCustomization setTextColor:textColor];
+        }
+
+        if (backgroundColor) {
+            [toolbarCustomization setBackgroundColor:backgroundColor];
+        }
+
+        if (headerText) {
+            [toolbarCustomization setHeaderText:headerText];
+        }
+
+        if (buttonText) {
+            [toolbarCustomization setButtonText:buttonText];
+        }
+
+        if (textFontSize) {
+            [toolbarCustomization setTextFontSize:textFontSize.integerValue];
+        }
+
+        [customization setToolbarCustomization:toolbarCustomization];
+    }
+
+    if (textBoxCustomizations) {
+        JP3DSTextBoxCustomization *textBoxCustomization = [JP3DSTextBoxCustomization new];
+
+        NSString *textFontName = [textBoxCustomizations optionalStringForKey:@"textFontName"];
+        NSString *textColor = [textBoxCustomizations optionalStringForKey:@"textColor"];
+        NSString *borderColor = [textBoxCustomizations optionalStringForKey:@"borderColor"];
+        NSNumber *borderWidth = [textBoxCustomizations optionalNumberForKey:@"borderWidth"];
+        NSNumber *cornerRadius = [textBoxCustomizations optionalNumberForKey:@"cornerRadius"];
+        NSNumber *textFontSize = [textBoxCustomizations optionalNumberForKey:@"textFontSize"];
+
+        if (textFontName) {
+            [textBoxCustomization setTextFontName:textFontName];
+        }
+
+        if (textColor) {
+            [textBoxCustomization setTextColor:textColor];
+        }
+
+        if (borderColor) {
+            [textBoxCustomization setBorderColor:borderColor];
+        }
+
+        if (borderWidth) {
+            [textBoxCustomization setBorderWidth:borderWidth.integerValue];
+        }
+
+        if (cornerRadius) {
+            [textBoxCustomization setCornerRadius:cornerRadius.integerValue];
+        }
+
+        if (textFontSize) {
+            [textBoxCustomization setTextFontSize:textFontSize.integerValue];
+        }
+
+        [customization setTextBoxCustomization:textBoxCustomization];
+    }
+
+    return customization;
+}
+
 + (JPTheme *)themeFromUIConfiguration:(NSDictionary *)uiConfiguration {
     JPTheme *theme = [JPTheme new];
 
@@ -463,38 +780,108 @@ static NSString *const kCardSchemeAMEX = @"amex";
     [mappedResponse setValue:response.appearsOnStatementAs forKey:@"appearsOnStatementAs"];
     [mappedResponse setValue:response.originalAmount forKey:@"originalAmount"];
     [mappedResponse setValue:response.netAmount forKey:@"netAmount"];
-    [mappedResponse setValue:response.amount.amount forKey:@"amount"];
-    [mappedResponse setValue:response.amount.currency forKey:@"currency"];
-
-    NSMutableDictionary *cardDetailsResponse = [NSMutableDictionary new];
-    [cardDetailsResponse setValue:response.cardDetails.cardLastFour forKey:@"cardLastFour"];
-    [cardDetailsResponse setValue:response.cardDetails.endDate forKey:@"endDate"];
-    [cardDetailsResponse setValue:response.cardDetails.cardToken forKey:@"cardToken"];
-    [cardDetailsResponse setValue:@(response.cardDetails.cardNetwork) forKey:@"cardNetwork"];
-    [cardDetailsResponse setValue:response.cardDetails.bank forKey:@"bank"];
-    [cardDetailsResponse setValue:response.cardDetails.cardCategory forKey:@"cardCategory"];
-    [cardDetailsResponse setValue:response.cardDetails.cardCountry forKey:@"cardCountry"];
-    [cardDetailsResponse setValue:response.cardDetails.cardFunding forKey:@"cardFunding"];
-    [cardDetailsResponse setValue:response.cardDetails.cardScheme forKey:@"cardScheme"];
-
-    [mappedResponse setValue:cardDetailsResponse forKey:@"cardDetails"];
-
-    NSMutableDictionary *consumerResponse = [NSMutableDictionary new];
-    [consumerResponse setValue:response.consumer.consumerToken forKey:@"consumerToken"];
-    [consumerResponse setValue:response.consumer.consumerReference forKey:@"consumerReference"];
-
-    [mappedResponse setValue:consumerResponse forKey:@"consumerResponse"];
-
-    NSMutableDictionary *orderDetailsResponse = [NSMutableDictionary new];
-    [orderDetailsResponse setValue:response.orderDetails.orderId forKey:@"orderId"];
-    [orderDetailsResponse setValue:response.orderDetails.orderStatus forKey:@"orderStatus"];
-    [orderDetailsResponse setValue:response.orderDetails.orderFailureReason forKey:@"orderFailureReason"];
-    [orderDetailsResponse setValue:response.orderDetails.timestamp forKey:@"timestamp"];
-    [orderDetailsResponse setValue:@(response.orderDetails.amount) forKey:@"amount"];
-
-    [mappedResponse setValue:orderDetailsResponse forKey:@"orderDetails"];
-
-    return mappedResponse;
-}
+
+    JPAmount *amount = response.amount;
+
+    if (amount) {
+        [mappedResponse setValue:amount.amount forKey:@"amount"];
+        [mappedResponse setValue:amount.currency forKey:@"currency"];
+    }
+
+    JPCardDetails *cardDetails = response.cardDetails;
+
+    if (cardDetails) {
+        NSMutableDictionary *cardDetailsDictionary = [NSMutableDictionary new];
+
+        if (cardDetails.cardLastFour) {
+            cardDetailsDictionary[@"cardLastFour"] = cardDetails.cardLastFour;
+        }
+
+        if (cardDetails.endDate) {
+            cardDetailsDictionary[@"endDate"] = cardDetails.endDate;
+        }
+
+        if (cardDetails.cardToken) {
+            cardDetailsDictionary[@"cardToken"] = cardDetails.cardToken;
+        }
+
+        cardDetailsDictionary[@"cardNetwork"] = @(cardDetails.cardNetwork);
+
+        if (cardDetails.bank) {
+            cardDetailsDictionary[@"bank"] = cardDetails.bank;
+        }
+
+        if (cardDetails.cardCategory) {
+            cardDetailsDictionary[@"cardCategory"] = cardDetails.cardCategory;
+        }
+
+        if (cardDetails.cardCountry) {
+            cardDetailsDictionary[@"cardCountry"] = cardDetails.cardCountry;
+        }
+
+        if (cardDetails.cardFunding) {
+            cardDetailsDictionary[@"cardFunding"] = cardDetails.cardFunding;
+        }
+
+        if (cardDetails.cardScheme) {
+            cardDetailsDictionary[@"cardScheme"] = cardDetails.cardScheme;
+        }
+
+        if (cardDetails.cardHolderName) {
+            cardDetailsDictionary[@"cardHolderName"] = cardDetails.cardHolderName;
+        }
+
+        [mappedResponse setValue:[NSDictionary dictionaryWithDictionary:cardDetailsDictionary]
+                          forKey:@"cardDetails"];
+    }
+
+    JPConsumer *consumer = response.consumer;
+
+    if (consumer) {
+        NSMutableDictionary *consumerDictionary = [NSMutableDictionary new];
+
+        if (consumer.consumerToken) {
+            consumerDictionary[@"consumerToken"] = consumer.consumerToken;
+        }
+
+        if (consumer.consumerReference) {
+            consumerDictionary[@"consumerReference"] = consumer.consumerReference;
+        }
+
+        if (consumerDictionary.count > 0) {
+            [mappedResponse setValue:[NSDictionary dictionaryWithDictionary:consumerDictionary]
+                              forKey:@"consumerResponse"];
+        }
+    }
+
+    JPOrderDetails *orderDetails = response.orderDetails;
+
+    if (orderDetails) {
+        NSMutableDictionary *orderDetailsDictionary = [NSMutableDictionary new];
+
+        if (orderDetails.orderId) {
+            orderDetailsDictionary[@"orderId"] = orderDetails.orderId;
+        }
+
+        if (orderDetails.orderStatus) {
+            orderDetailsDictionary[@"orderStatus"] = orderDetails.orderStatus;
+        }
+
+        if (orderDetails.orderFailureReason) {
+            orderDetailsDictionary[@"orderFailureReason"] = orderDetails.orderFailureReason;
+        }
+
+        if (orderDetails.timestamp) {
+            orderDetailsDictionary[@"timestamp"] = orderDetails.timestamp;
+        }
+
+        orderDetailsDictionary[@"amount"] = @(orderDetails.amount);
+
+        [mappedResponse setValue:[NSDictionary dictionaryWithDictionary:orderDetailsDictionary]
+                          forKey:@"orderDetails"];
+    }
+
+    return [NSDictionary dictionaryWithDictionary:mappedResponse];
+    }
 
 @end

package/ios/Podfile

@@ -19,7 +19,9 @@ target 'RNJudo' do
   # use_frameworks!
 
   # Pods for RNJudo
-  pod "JudoKit-iOS", "3.1.8"
+  pod "JudoKit-iOS", "3.1.10"
+  pod "Judo3DS2_iOS", "1.1.3"
+
   pod 'FBLazyVector', :path => "../node_modules/react-native/Libraries/FBLazyVector"
   pod 'FBReactNativeSpec', :path => "../node_modules/react-native/Libraries/FBReactNativeSpec"
   pod 'RCTRequired', :path => "../node_modules/react-native/Libraries/RCTRequired"

package/ios/Podfile.lock

@@ -22,7 +22,7 @@ PODS:
     - glog
   - glog (0.3.5)
   - Judo3DS2_iOS (1.1.3)
-  - JudoKit-iOS (3.1.7):
+  - JudoKit-iOS (3.1.10):
     - DeviceDNA (~> 2.0.0)
     - Judo3DS2_iOS (~> 1.1.3)
     - TrustKit
@@ -236,7 +236,8 @@ DEPENDENCIES:
   - FBReactNativeSpec (from `../node_modules/react-native/Libraries/FBReactNativeSpec`)
   - Folly (from `../node_modules/react-native/third-party-podspecs/Folly.podspec`)
   - glog (from `../node_modules/react-native/third-party-podspecs/glog.podspec`)
-  - JudoKit-iOS (= 3.1.7)
+  - Judo3DS2_iOS (= 1.1.3)
+  - JudoKit-iOS (= 3.1.10)
   - RCTRequired (from `../node_modules/react-native/Libraries/RCTRequired`)
   - RCTTypeSafety (from `../node_modules/react-native/Libraries/TypeSafety`)
   - React (from `../node_modules/react-native/`)
@@ -332,7 +333,7 @@ SPEC CHECKSUMS:
   Folly: 30e7936e1c45c08d884aa59369ed951a8e68cf51
   glog: 1f3da668190260b06b429bb211bfbee5cd790c28
   Judo3DS2_iOS: b2396a1f0aa3e8d428fdd887c8b6eae5d3aa4f79
-  JudoKit-iOS: 9bdb404617132df3a22ce0713b610258fbc9a817
+  JudoKit-iOS: c45f288b94eef55d779b4e61028b9bf04aa334b2
   OpenSSL-Universal: 84efb8a29841f2764ac5403e0c4119a28b713346
   RCTRequired: b153add4da6e7dbc44aebf93f3cf4fcae392ddf1
   RCTTypeSafety: 9aa1b91d7f9310fc6eadc3cf95126ffe818af320
@@ -357,6 +358,6 @@ SPEC CHECKSUMS:
   Yoga: f2a7cd4280bfe2cca5a7aed98ba0eb3d1310f18b
   ZappMerchantLib: b14bc5814840426d351190309250347ca9b0983d
 
-PODFILE CHECKSUM: b43fb77cd20fdc9f4c3ce03edc13aa92f131243b
+PODFILE CHECKSUM: f04f2f5cb9ebec38d61aa9e7bdf575cf58376fdd
 
 COCOAPODS: 1.11.3

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "judokit-react-native",
     "title": "Judopay React Native Module",
-    "version": "3.4.8",
+    "version": "3.5.0",
     "description": "A React Native module for the Judopay native SDKs to take payments on iOS and Android.",
     "main": "JudoPay.tsx",
     "scripts": {
         "test": "jest --coverage",
-        "lint": "tsc && eslint '*/**/*.{js,ts,tsx}' --quiet"
+        "lint": "tsc && eslint '*/**/*.{ts,tsx}' --quiet",
+        "format": "prettier --write \"**/*.+(tsx|ts)\""
     },
     "files": [
         "JudoPay.tsx",
@@ -52,6 +53,7 @@
         "eslint-plugin-react": "^7.19.0",
         "eslint-plugin-react-hooks": "^2.5.0",
         "jest": "^25.3.0",
+        "prettier": "^2.7.1",
         "react": "16.9.0",
         "react-native": "0.61.5"
     },

package/types/JudoTypes.tsx

@@ -15,33 +15,34 @@ export interface JudoConfiguration {
     googlePayConfiguration?: JudoGooglePayConfiguration
     pbbaConfiguration?: JudoPBBAConfiguration
     isInitialRecurringPayment?: boolean
-    networkTimeout?: NetworkTimeout,
-    challengeRequestIndicator?: ChallengeRequestIndicator,
-    scaExemption?: ScaExemption,
-    mobileNumber?: string,
-    phoneCountryCode?: string,
-    emailAddress?: string,
-    threeDSTwoMaxTimeout?: string,
+    networkTimeout?: NetworkTimeout
+    challengeRequestIndicator?: ChallengeRequestIndicator
+    scaExemption?: ScaExemption
+    mobileNumber?: string
+    phoneCountryCode?: string
+    emailAddress?: string
+    threeDSTwoMaxTimeout?: number
     threeDSTwoMessageVersion?: string
+    isDelayedAuthorisation?: boolean
 }
 
 export enum ChallengeRequestIndicator {
-    NoPreference = "noPreference",
-    NoChallenge = "noChallenge",
-    ChallengePreferred = "challengePreferred",
-    ChallengeAsMandate = "challengeAsMandate"
+    NoPreference = 'noPreference',
+    NoChallenge = 'noChallenge',
+    ChallengePreferred = 'challengePreferred',
+    ChallengeAsMandate = 'challengeAsMandate'
 }
 
 export enum ScaExemption {
-    LowValue = "lowValue",
-    SecureCorporate = "secureCorporate",
-    TrustedBeneficiary = "trustedBeneficiary",
-    TransactionRiskAnalysis = "transactionRiskAnalysis"
+    LowValue = 'lowValue',
+    SecureCorporate = 'secureCorporate',
+    TrustedBeneficiary = 'trustedBeneficiary',
+    TransactionRiskAnalysis = 'transactionRiskAnalysis'
 }
 
 export interface NetworkTimeout {
-    connectTimeout?: number,
-    readTimeout?: number,
+    connectTimeout?: number
+    readTimeout?: number
     writeTimeout?: number
 }
 
@@ -85,6 +86,58 @@ export interface JudoAddress {
     state?: string
 }
 
+export interface JudoThreeDSToolbarCustomization {
+    backgroundColor?: string
+    headerText?: string
+    buttonText?: string
+    textFontName?: string
+    textColor?: string
+    textFontSize?: number
+}
+
+export interface JudoThreeDSLabelCustomization {
+    headingTextFontName?: string
+    headingTextColor?: string
+    headingTextFontSize?: number
+    textFontName?: string
+    textColor?: string
+    textFontSize?: number
+}
+
+export interface JudoThreeDSTextBoxCustomization {
+    borderWidth?: number
+    borderColor?: string
+    cornerRadius?: number
+    textFontName?: string
+    textColor?: string
+    textFontSize?: number
+}
+
+export enum JudoThreeDSButtonType {
+    SUBMIT = 'SUBMIT',
+    CONTINUE = 'CONTINUE',
+    NEXT = 'NEXT',
+    CANCEL = 'CANCEL',
+    RESEND = 'RESEND'
+}
+
+export interface JudoThreeDSButtonCustomization {
+    backgroundColor?: string
+    cornerRadius?: number
+    textFontName?: string
+    textColor?: string
+    textFontSize?: number
+}
+
+export interface JudoThreeDSUIConfiguration {
+    buttonCustomizations?: Partial<
+        Record<JudoThreeDSButtonType, JudoThreeDSButtonCustomization>
+    >
+    toolbarCustomization?: JudoThreeDSToolbarCustomization
+    labelCustomization?: JudoThreeDSLabelCustomization
+    textBoxCustomization?: JudoThreeDSTextBoxCustomization
+}
+
 export interface JudoUIConfiguration {
     isAVSEnabled: boolean
     shouldPaymentMethodsDisplayAmount: boolean
@@ -92,6 +145,7 @@ export interface JudoUIConfiguration {
     shouldPaymentMethodsVerifySecurityCode: boolean
     shouldAskForBillingInformation?: boolean
     theme?: JudoTheme
+    threeDSUIConfiguration?: JudoThreeDSUIConfiguration
 }
 
 export interface JudoTheme {