@primer-io/react-native 2.30.0 → 2.30.2

package/android/src/main/java/com/primerioreactnative/components/manager/raw/PrimerRNHeadlessUniversalCheckoutRawManager.kt

@@ -1,6 +1,11 @@
 package com.primerioreactnative.components.manager.raw
 
-import com.facebook.react.bridge.*
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.primerioreactnative.Keys
 import com.primerioreactnative.components.datamodels.core.PrimerRawPaymentMethodType
@@ -14,193 +19,213 @@ import com.primerioreactnative.datamodels.ErrorTypeRN
 import com.primerioreactnative.datamodels.PrimerErrorRN
 import com.primerioreactnative.utils.errorTo
 import com.primerioreactnative.utils.toWritableMap
-import io.primer.android.core.ExperimentalPrimerApi
+import io.primer.android.RetailOutletsList
 import io.primer.android.components.SdkUninitializedException
 import io.primer.android.components.domain.exception.UnsupportedPaymentMethodManagerException
 import io.primer.android.components.manager.raw.PrimerHeadlessUniversalCheckoutRawDataManager
 import io.primer.android.components.manager.raw.PrimerHeadlessUniversalCheckoutRawDataManagerInterface
-import io.primer.android.RetailOutletsList
+import io.primer.android.core.ExperimentalPrimerApi
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.json.JSONArray
 import org.json.JSONObject
 
-
+@Suppress("TooManyFunctions")
 @ExperimentalPrimerApi
 internal class PrimerRNHeadlessUniversalCheckoutRawManager(
-  reactContext: ReactApplicationContext,
-  private val json: Json,
+    reactContext: ReactApplicationContext,
+    private val json: Json,
 ) : ReactContextBaseJavaModule(reactContext) {
+    private val listener = PrimerRNHeadlessUniversalCheckoutRawManagerListener()
+    private lateinit var rawManager: PrimerHeadlessUniversalCheckoutRawDataManagerInterface
+    private var paymentMethodTypeStr: String? = null
 
-  private val listener = PrimerRNHeadlessUniversalCheckoutRawManagerListener()
-  private lateinit var rawManager: PrimerHeadlessUniversalCheckoutRawDataManagerInterface
-  private var paymentMethodTypeStr: String? = null
-
-  init {
-    listener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }
-  }
-
-  override fun getName() = "RNTPrimerHeadlessUniversalCheckoutRawDataManager"
-
-  @ReactMethod
-  fun configure(paymentMethodTypeStr: String, promise: Promise) {
-    try {
-      rawManager = PrimerHeadlessUniversalCheckoutRawDataManager.newInstance(
-        paymentMethodTypeStr
-      )
-      this.paymentMethodTypeStr = paymentMethodTypeStr
-      rawManager.setListener(listener)
-      rawManager.configure { primerInitializationData, error ->
-        if (error == null) {
-          when (primerInitializationData) {
-            is RetailOutletsList -> {
-              promise.resolve(
-                prepareData(
-                  JSONObject().apply {
-                    put(
-                      "initializationData", JSONObject(
-                        Json.encodeToString(
-                          primerInitializationData.toRNRetailOutletsList()
-                        )
-                      )
-                    )
-                  }
+    init {
+        listener.sendEvent = { eventName, paramsJson -> sendEvent(eventName, paramsJson) }
+    }
+
+    override fun getName() = "RNTPrimerHeadlessUniversalCheckoutRawDataManager"
+
+    @ReactMethod
+    fun configure(
+        paymentMethodTypeStr: String,
+        promise: Promise,
+    ) {
+        try {
+            rawManager =
+                PrimerHeadlessUniversalCheckoutRawDataManager.newInstance(
+                    paymentMethodTypeStr,
                 )
-              )
+            this.paymentMethodTypeStr = paymentMethodTypeStr
+            rawManager.setListener(listener)
+            rawManager.configure { primerInitializationData, error ->
+                if (error == null) {
+                    when (primerInitializationData) {
+                        is RetailOutletsList -> {
+                            promise.resolve(
+                                prepareData(
+                                    JSONObject().apply {
+                                        put(
+                                            "initializationData",
+                                            JSONObject(
+                                                Json.encodeToString(
+                                                    primerInitializationData.toRNRetailOutletsList(),
+                                                ),
+                                            ),
+                                        )
+                                    },
+                                ),
+                            )
+                        }
+
+                        else -> promise.resolve(null)
+                    }
+                } else {
+                    promise.reject(error.errorId, error.description)
+                }
             }
-            else -> promise.resolve(null)
-          }
-        } else promise.reject(error.errorId, error.description)
-      }
-    } catch (e: SdkUninitializedException) {
-      promise.reject(ErrorTypeRN.UnitializedSdkSession.errorId, e.message, e)
-    } catch (e: UnsupportedPaymentMethodManagerException) {
-      promise.reject(ErrorTypeRN.UnsupportedPaymentMethod.errorId, e.message, e)
-    } catch (e: Exception) {
-      val exception =
-        ErrorTypeRN.NativeBridgeFailed errorTo e.message.orEmpty()
-      promise.reject(exception.errorId, exception.description, e)
+        } catch (e: SdkUninitializedException) {
+            promise.reject(ErrorTypeRN.UnitializedSdkSession.errorId, e.message, e)
+        } catch (e: UnsupportedPaymentMethodManagerException) {
+            promise.reject(ErrorTypeRN.UnsupportedPaymentMethod.errorId, e.message, e)
+        } catch (e: Exception) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo e.message.orEmpty()
+            promise.reject(exception.errorId, exception.description, e)
+        }
     }
-  }
-
-  @ReactMethod
-  fun listRequiredInputElementTypes(
-    promise: Promise
-  ) {
-    if (::rawManager.isInitialized.not()) {
-      val exception =
-        ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
-      promise.reject(exception.errorId, exception.description)
-    } else {
-      promise.resolve(
-        prepareData(
-          JSONObject().apply {
-            put(
-              "inputElementTypes",
-              JSONArray(rawManager.getRequiredInputElementTypes().map { it.name })
+
+    @ReactMethod
+    fun listRequiredInputElementTypes(promise: Promise) {
+        if (::rawManager.isInitialized.not()) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
+            promise.reject(exception.errorId, exception.description)
+        } else {
+            promise.resolve(
+                prepareData(
+                    JSONObject().apply {
+                        put(
+                            "inputElementTypes",
+                            JSONArray(rawManager.getRequiredInputElementTypes().map { it.name }),
+                        )
+                    },
+                ),
             )
-          }
-        )
-      )
+        }
     }
-  }
-
-  @ReactMethod
-  fun setRawData(rawDataStr: String, promise: Promise) {
-    if (::rawManager.isInitialized.not()) {
-      val exception =
-        ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
-      promise.reject(exception.errorId, exception.description)
-    } else {
-      try {
-        val rawData = when (PrimerRawPaymentMethodType.valueOf(paymentMethodTypeStr.toString())) {
-          PrimerRawPaymentMethodType.PAYMENT_CARD -> json.decodeFromString<PrimerRNCardData>(
-            rawDataStr
-          ).toPrimerCardData()
-          PrimerRawPaymentMethodType.XENDIT_OVO,
-          PrimerRawPaymentMethodType.ADYEN_MBWAY ->
-            json.decodeFromString<PrimerRNPhoneNumberData>(rawDataStr)
-              .toPrimerPhoneNumberData()
-          PrimerRawPaymentMethodType.ADYEN_BANCONTACT_CARD ->
-            json.decodeFromString<PrimerRNBancontactCardData>(rawDataStr)
-              .toPrimerBancontactCardData()
-          PrimerRawPaymentMethodType.XENDIT_RETAIL_OUTLETS ->
-            json.decodeFromString<PrimerRNRetailOutletData>(rawDataStr)
-              .toPrimerRetailOutletData()
+
+    @ReactMethod
+    fun setRawData(
+        rawDataStr: String,
+        promise: Promise,
+    ) {
+        if (::rawManager.isInitialized.not()) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
+            promise.reject(exception.errorId, exception.description)
+        } else {
+            try {
+                val rawData =
+                    when (PrimerRawPaymentMethodType.valueOf(paymentMethodTypeStr.toString())) {
+                        PrimerRawPaymentMethodType.PAYMENT_CARD ->
+                            json.decodeFromString<PrimerRNCardData>(
+                                rawDataStr,
+                            ).toPrimerCardData()
+
+                        PrimerRawPaymentMethodType.XENDIT_OVO,
+                        PrimerRawPaymentMethodType.ADYEN_MBWAY,
+                        ->
+                            json.decodeFromString<PrimerRNPhoneNumberData>(rawDataStr)
+                                .toPrimerPhoneNumberData()
+
+                        PrimerRawPaymentMethodType.ADYEN_BANCONTACT_CARD ->
+                            json.decodeFromString<PrimerRNBancontactCardData>(rawDataStr)
+                                .toPrimerBancontactCardData()
+
+                        PrimerRawPaymentMethodType.XENDIT_RETAIL_OUTLETS ->
+                            json.decodeFromString<PrimerRNRetailOutletData>(rawDataStr)
+                                .toPrimerRetailOutletData()
+                    }
+                rawManager.setRawData(rawData)
+                promise.resolve(null)
+            } catch (e: Exception) {
+                val exception =
+                    ErrorTypeRN.NativeBridgeFailed errorTo "Failed to decode $rawDataStr on Android." +
+                        " Make sure you're providing a valid 'RawData' (or any inherited) object."
+                onError(exception)
+                promise.reject(exception.errorId, exception.description, e)
+            }
         }
-        rawManager.setRawData(rawData)
-        promise.resolve(null)
-      } catch (e: Exception) {
-        val exception =
-          ErrorTypeRN.NativeBridgeFailed errorTo "Failed to decode $rawDataStr on Android." +
-            " Make sure you're providing a valid 'RawData' (or any inherited) object."
-        onError(exception)
-        promise.reject(exception.errorId, exception.description, e)
-      }
     }
-  }
-
-  @ReactMethod
-  fun submit(promise: Promise) {
-    if (::rawManager.isInitialized.not()) {
-      val exception =
-        ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
-      promise.reject(exception.errorId, exception.description)
-    } else {
-      rawManager.submit()
-      promise.resolve(null)
+
+    @ReactMethod
+    fun submit(promise: Promise) {
+        if (::rawManager.isInitialized.not()) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
+            promise.reject(exception.errorId, exception.description)
+        } else {
+            rawManager.submit()
+            promise.resolve(null)
+        }
     }
-  }
-
-  @ReactMethod
-  fun cleanUp(promise: Promise) {
-    if (::rawManager.isInitialized.not()) {
-      val exception =
-        ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
-      promise.reject(exception.errorId, exception.description)
-    } else {
-      rawManager.cleanup()
-      promise.resolve(null)
+
+    @ReactMethod
+    fun cleanUp(promise: Promise) {
+        if (::rawManager.isInitialized.not()) {
+            val exception =
+                ErrorTypeRN.NativeBridgeFailed errorTo UNINITIALIZED_ERROR
+            promise.reject(exception.errorId, exception.description)
+        } else {
+            rawManager.cleanup()
+            promise.resolve(null)
+        }
     }
-  }
-
-  @ReactMethod
-  fun addListener(eventName: String?) = Unit
-
-  @ReactMethod
-  fun removeListeners(count: Int?) = Unit
-
-  private fun sendEvent(name: String, params: WritableMap) {
-    reactApplicationContext.getJSModule(
-      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
-    ).emit(name, params)
-  }
-
-  private fun sendEvent(name: String, data: JSONObject?) {
-    val params = prepareData(data)
-    reactApplicationContext.getJSModule(
-      DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
-    ).emit(name, params)
-  }
-
-  private fun prepareData(data: JSONObject?): WritableMap {
-    return data.toWritableMap()
-  }
-
-  private fun onError(exception: PrimerErrorRN) {
-    val params = Arguments.createMap()
-    val errorJson = JSONObject(Json.encodeToString(exception))
-    val errorData = prepareData(errorJson)
-    params.putMap(Keys.ERROR, errorData)
-    sendEvent(PrimerHeadlessUniversalCheckoutEvent.ON_ERROR.eventName, params)
-  }
-
-  private companion object {
-    const val UNINITIALIZED_ERROR =
-      """
+
+    @ReactMethod
+    fun addListener(eventName: String?) = Unit
+
+    @ReactMethod
+    fun removeListeners(count: Int?) = Unit
+
+    private fun sendEvent(
+        name: String,
+        params: WritableMap,
+    ) {
+        reactApplicationContext.getJSModule(
+            DeviceEventManagerModule.RCTDeviceEventEmitter::class.java,
+        ).emit(name, params)
+    }
+
+    private fun sendEvent(
+        name: String,
+        data: JSONObject?,
+    ) {
+        val params = prepareData(data)
+        reactApplicationContext.getJSModule(
+            DeviceEventManagerModule.RCTDeviceEventEmitter::class.java,
+        ).emit(name, params)
+    }
+
+    private fun prepareData(data: JSONObject?): WritableMap {
+        return data.toWritableMap()
+    }
+
+    private fun onError(exception: PrimerErrorRN) {
+        val params = Arguments.createMap()
+        val errorJson = JSONObject(Json.encodeToString(exception))
+        val errorData = prepareData(errorJson)
+        params.putMap(Keys.ERROR, errorData)
+        sendEvent(PrimerHeadlessUniversalCheckoutEvent.ON_ERROR.eventName, params)
+    }
+
+    private companion object {
+        const val UNINITIALIZED_ERROR =
+            """
         The RawDataManager has not been initialized.
         Make sure you have initialized the `RawDataManager' first.
       """
-  }
+    }
 }

package/android/src/main/java/com/primerioreactnative/components/manager/raw/PrimerRNHeadlessUniversalCheckoutRawManagerListener.kt

@@ -2,11 +2,11 @@ package com.primerioreactnative.components.manager.raw
 
 import com.primerioreactnative.components.events.PrimerHeadlessUniversalCheckoutRawDataManagerEvent
 import com.primerioreactnative.datamodels.PrimerInputValidationErrorRN
-import io.primer.android.core.ExperimentalPrimerApi
 import io.primer.android.components.domain.core.models.card.PrimerCardMetadata
 import io.primer.android.components.domain.core.models.metadata.PrimerPaymentMethodMetadata
 import io.primer.android.components.domain.error.PrimerInputValidationError
 import io.primer.android.components.manager.raw.PrimerHeadlessUniversalCheckoutRawDataManagerListener
+import io.primer.android.core.ExperimentalPrimerApi
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.json.JSONArray
@@ -14,44 +14,46 @@ import org.json.JSONObject
 
 @ExperimentalPrimerApi
 internal class PrimerRNHeadlessUniversalCheckoutRawManagerListener :
-  PrimerHeadlessUniversalCheckoutRawDataManagerListener {
+    PrimerHeadlessUniversalCheckoutRawDataManagerListener {
+    var sendEvent: ((eventName: String, paramsJson: JSONObject?) -> Unit)? = null
 
-  var sendEvent: ((eventName: String, paramsJson: JSONObject?) -> Unit)? = null
-
-  override fun onValidationChanged(isValid: Boolean, errors: List<PrimerInputValidationError>) {
-    sendEvent?.invoke(
-      PrimerHeadlessUniversalCheckoutRawDataManagerEvent.ON_VALIDATION_CHANGED.eventName,
-      JSONObject().apply {
-        put("isValid", isValid)
-        put(
-          "errors",
-          JSONArray(
-            errors.map {
-              JSONObject(
-                Json.encodeToString(
-                  PrimerInputValidationErrorRN(
-                    it.errorId,
-                    it.description,
-                    it.inputElementType.name,
-                    it.diagnosticsId
-                  )
+    override fun onValidationChanged(
+        isValid: Boolean,
+        errors: List<PrimerInputValidationError>,
+    ) {
+        sendEvent?.invoke(
+            PrimerHeadlessUniversalCheckoutRawDataManagerEvent.ON_VALIDATION_CHANGED.eventName,
+            JSONObject().apply {
+                put("isValid", isValid)
+                put(
+                    "errors",
+                    JSONArray(
+                        errors.map {
+                            JSONObject(
+                                Json.encodeToString(
+                                    PrimerInputValidationErrorRN(
+                                        it.errorId,
+                                        it.description,
+                                        it.inputElementType.name,
+                                        it.diagnosticsId,
+                                    ),
+                                ),
+                            )
+                        },
+                    ),
                 )
-              )
-            }
-          )
+            },
         )
-      }
-    )
-  }
+    }
 
-  override fun onMetadataChanged(metadata: PrimerPaymentMethodMetadata) {
-    sendEvent?.invoke(
-      PrimerHeadlessUniversalCheckoutRawDataManagerEvent.ON_METADATA_CHANGED.eventName,
-      JSONObject().apply {
-        if (metadata is PrimerCardMetadata) {
-          put("cardNetwork", metadata.cardNetwork.name)
-        }
-      }
-    )
-  }
+    override fun onMetadataChanged(metadata: PrimerPaymentMethodMetadata) {
+        sendEvent?.invoke(
+            PrimerHeadlessUniversalCheckoutRawDataManagerEvent.ON_METADATA_CHANGED.eventName,
+            JSONObject().apply {
+                if (metadata is PrimerCardMetadata) {
+                    put("cardNetwork", metadata.cardNetwork.name)
+                }
+            },
+        )
+    }
 }