@stripe/stripe-react-native 0.44.0 → 0.45.0

package/android/src/main/java/com/reactnativestripesdk/CardFormCompleteEvent.kt

@@ -10,29 +10,30 @@ internal class CardFormCompleteEvent(
   private val cardDetails: MutableMap<String, Any>?,
   private val complete: Boolean,
   private val dangerouslyGetFullCardDetails: Boolean,
-) : Event<CardChangedEvent>(surfaceId, viewTag) {
+) : Event<CardChangeEvent>(surfaceId, viewTag) {
   override fun getEventName() = EVENT_NAME
 
   override fun getEventData(): WritableMap? {
-    val eventData = Arguments.createMap()
+    val cardData = Arguments.createMap()
 
-    if (cardDetails == null) {
-      return eventData
-    }
-    eventData.putString("brand", cardDetails["brand"]?.toString())
-    eventData.putString("last4", cardDetails["last4"]?.toString())
-    eventData.putString("country", cardDetails["country"]?.toString())
-    eventData.putInt("expiryMonth", cardDetails["expiryMonth"] as Int)
-    eventData.putInt("expiryYear", cardDetails["expiryYear"] as Int)
-    eventData.putBoolean("complete", complete)
-    eventData.putString("postalCode", cardDetails["postalCode"]?.toString())
+    if (cardDetails != null) {
+      cardData.putString("brand", cardDetails["brand"]?.toString())
+      cardData.putString("last4", cardDetails["last4"]?.toString())
+      cardData.putString("country", cardDetails["country"]?.toString())
+      cardData.putInt("expiryMonth", cardDetails["expiryMonth"] as Int)
+      cardData.putInt("expiryYear", cardDetails["expiryYear"] as Int)
+      cardData.putBoolean("complete", complete)
+      cardData.putString("postalCode", cardDetails["postalCode"]?.toString())
 
-    if (dangerouslyGetFullCardDetails) {
-      eventData.putString("number", cardDetails["number"]?.toString()?.replace(" ", ""))
-      eventData.putString("cvc", cardDetails["cvc"]?.toString())
+      if (dangerouslyGetFullCardDetails) {
+        cardData.putString("number", cardDetails["number"]?.toString()?.replace(" ", ""))
+        cardData.putString("cvc", cardDetails["cvc"]?.toString())
+      }
     }
 
-    return eventData
+    return Arguments.createMap().apply {
+      putMap("card", cardData)
+    }
   }
 
   companion object {

package/android/src/main/java/com/reactnativestripesdk/CardFormView.kt

@@ -65,8 +65,8 @@ class CardFormView(
     cardFormViewBinding.postalCodeContainer.visibility = visibility
   }
 
-  fun setDefaultValues(defaults: ReadableMap) {
-    setCountry(defaults.getString("countryCode"))
+  fun setDefaultValues(defaults: ReadableMap?) {
+    setCountry(defaults?.getString("countryCode"))
   }
 
   fun setDisabled(isDisabled: Boolean) {
@@ -86,7 +86,7 @@ class CardFormView(
     setPostalCodeFilter()
   }
 
-  fun setPlaceHolders(value: ReadableMap) {
+  fun setPlaceHolders(value: ReadableMap?) {
     val numberPlaceholder = getValOr(value, "number", null)
     val expirationPlaceholder = getValOr(value, "expiration", null)
     val cvcPlaceholder = getValOr(value, "cvc", null)
@@ -136,11 +136,11 @@ class CardFormView(
   private fun onChangeFocus() {
     UIManagerHelper
       .getEventDispatcherForReactTag(context, id)
-      ?.dispatchEvent(CardFocusEvent(context.surfaceId, id, currentFocusedField))
+      ?.dispatchEvent(CardFocusChangeEvent(context.surfaceId, id, currentFocusedField))
   }
 
   @SuppressLint("RestrictedApi")
-  fun setCardStyle(value: ReadableMap) {
+  fun setCardStyle(value: ReadableMap?) {
     val backgroundColor = getValOr(value, "backgroundColor", null)
     val textColor = getValOr(value, "textColor", null)
     val borderWidth = getIntOrNull(value, "borderWidth")

package/android/src/main/java/com/reactnativestripesdk/CardFormViewManager.kt

@@ -1,86 +1,82 @@
 package com.reactnativestripesdk
 
+import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.CardFormManagerDelegate
+import com.facebook.react.viewmanagers.CardFormManagerInterface
+import com.reactnativestripesdk.utils.asMapOrNull
 
 @ReactModule(name = CardFormViewManager.REACT_CLASS)
-class CardFormViewManager : SimpleViewManager<CardFormView>() {
+class CardFormViewManager :
+  SimpleViewManager<CardFormView>(),
+  CardFormManagerInterface<CardFormView> {
+  private val delegate = CardFormManagerDelegate(this)
+  private var reactContextRef: ThemedReactContext? = null
+
   override fun getName() = REACT_CLASS
 
-  private var reactContextRef: ThemedReactContext? = null
+  override fun getDelegate() = delegate
 
   override fun getExportedCustomDirectEventTypeConstants() =
     mutableMapOf(
-      CardFocusEvent.EVENT_NAME to mutableMapOf("registrationName" to "onFocusChange"),
+      CardFocusChangeEvent.EVENT_NAME to mutableMapOf("registrationName" to "onFocusChange"),
       CardFormCompleteEvent.EVENT_NAME to mutableMapOf("registrationName" to "onFormComplete"),
     )
 
-  override fun receiveCommand(
-    root: CardFormView,
-    commandId: String?,
-    args: ReadableArray?,
-  ) {
-    when (commandId) {
-      "focus" -> root.requestFocusFromJS()
-      "blur" -> root.requestBlurFromJS()
-      "clear" -> root.requestClearFromJS()
-    }
-  }
-
   @ReactProp(name = "dangerouslyGetFullCardDetails")
-  fun setDangerouslyGetFullCardDetails(
+  override fun setDangerouslyGetFullCardDetails(
     view: CardFormView,
-    dangerouslyGetFullCardDetails: Boolean = false,
+    dangerouslyGetFullCardDetails: Boolean,
   ) {
     view.setDangerouslyGetFullCardDetails(dangerouslyGetFullCardDetails)
   }
 
   @ReactProp(name = "postalCodeEnabled")
-  fun setPostalCodeEnabled(
+  override fun setPostalCodeEnabled(
     view: CardFormView,
-    postalCodeEnabled: Boolean = false,
+    postalCodeEnabled: Boolean,
   ) {
     view.setPostalCodeEnabled(postalCodeEnabled)
   }
 
   @ReactProp(name = "placeholders")
-  fun setPlaceHolders(
+  override fun setPlaceholders(
     view: CardFormView,
-    placeholders: ReadableMap,
+    placeholders: Dynamic,
   ) {
-    view.setPlaceHolders(placeholders)
+    view.setPlaceHolders(placeholders.asMapOrNull())
   }
 
   @ReactProp(name = "autofocus")
-  fun setAutofocus(
+  override fun setAutofocus(
     view: CardFormView,
-    autofocus: Boolean = false,
+    autofocus: Boolean,
   ) {
     view.setAutofocus(autofocus)
   }
 
   @ReactProp(name = "cardStyle")
-  fun setCardStyle(
+  override fun setCardStyle(
     view: CardFormView,
-    cardStyle: ReadableMap,
+    cardStyle: Dynamic,
   ) {
-    view.setCardStyle(cardStyle)
+    view.setCardStyle(cardStyle.asMapOrNull())
   }
 
   @ReactProp(name = "defaultValues")
-  fun setDefaultValues(
+  override fun setDefaultValues(
     view: CardFormView,
-    defaults: ReadableMap,
+    defaults: Dynamic,
   ) {
-    view.setDefaultValues(defaults)
+    view.setDefaultValues(defaults.asMapOrNull())
   }
 
   @ReactProp(name = "disabled")
-  fun setDisabled(
+  override fun setDisabled(
     view: CardFormView,
     isDisabled: Boolean,
   ) {
@@ -88,7 +84,7 @@ class CardFormViewManager : SimpleViewManager<CardFormView>() {
   }
 
   @ReactProp(name = "preferredNetworks")
-  fun setPreferredNetworks(
+  override fun setPreferredNetworks(
     view: CardFormView,
     preferredNetworks: ReadableArray?,
   ) {
@@ -116,6 +112,16 @@ class CardFormViewManager : SimpleViewManager<CardFormView>() {
     reactContextRef = null
   }
 
+  // Native commands
+
+  override fun blur(view: CardFormView) {
+    view.requestBlurFromJS()
+  }
+
+  override fun focus(view: CardFormView) {
+    view.requestFocusFromJS()
+  }
+
   companion object {
     const val REACT_CLASS = "CardForm"
   }

package/android/src/main/java/com/reactnativestripesdk/CollectBankAccountLauncherFragment.kt

@@ -38,10 +38,10 @@ class CollectBankAccountLauncherFragment(
     super.onCreate(savedInstanceState)
 
     val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
-    if (stripeSdkModule != null && stripeSdkModule.eventListenerCount > 0) {
+    if (stripeSdkModule != null) {
       FinancialConnections.setEventListener { event ->
         val params = mapFromFinancialConnectionsEvent(event)
-        stripeSdkModule.sendEvent(context, "onFinancialConnectionsEvent", params)
+        stripeSdkModule.emitOnFinancialConnectionsEvent(params)
       }
     }
   }
@@ -108,11 +108,13 @@ class CollectBankAccountLauncherFragment(
             )
           }
         }
+
         is CollectBankAccountResult.Cancelled -> {
           promise.resolve(
             createError(ErrorType.Canceled.toString(), "Bank account collection was canceled."),
           )
         }
+
         is CollectBankAccountResult.Failed -> {
           promise.resolve(createError(ErrorType.Failed.toString(), result.error))
         }

package/android/src/main/java/com/reactnativestripesdk/EmbeddedPaymentElementView.kt

@@ -0,0 +1,182 @@
+package com.reactnativestripesdk
+
+import android.content.Context
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.platform.AbstractComposeView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.reactnativestripesdk.utils.mapFromPaymentMethod
+import com.stripe.android.paymentelement.EmbeddedPaymentElement
+import com.stripe.android.paymentelement.ExperimentalEmbeddedPaymentElementApi
+import com.stripe.android.paymentelement.rememberEmbeddedPaymentElement
+import com.stripe.android.paymentsheet.CreateIntentResult
+import com.stripe.android.paymentsheet.PaymentSheet
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.consumeAsFlow
+import toWritableMap
+
+@OptIn(ExperimentalEmbeddedPaymentElementApi::class)
+class EmbeddedPaymentElementView(
+  context: Context,
+) : AbstractComposeView(context) {
+  private sealed interface Event {
+    data class Configure(
+      val configuration: EmbeddedPaymentElement.Configuration,
+      val intentConfiguration: PaymentSheet.IntentConfiguration,
+    ) : Event
+
+    data object Confirm : Event
+
+    data object ClearPaymentOption : Event
+  }
+
+  var latestIntentConfig: PaymentSheet.IntentConfiguration? = null
+  var latestElementConfig: EmbeddedPaymentElement.Configuration? = null
+
+  private val reactContext get() = context as ReactContext
+  private val events = Channel<Event>(Channel.UNLIMITED)
+
+  private val builder by lazy {
+    EmbeddedPaymentElement.Builder(
+      createIntentCallback = { paymentMethod, shouldSavePaymentMethod ->
+        val stripeSdkModule =
+          try {
+            requireStripeSdkModule()
+          } catch (ex: IllegalArgumentException) {
+            return@Builder CreateIntentResult.Failure(
+              cause =
+                Exception(
+                  "Tried to call confirmHandler, but no callback was found. Please file an issue: https://github.com/stripe/stripe-react-native/issues",
+                ),
+              displayMessage = "An unexpected error occurred",
+            )
+          }
+        val params =
+          Arguments.createMap().apply {
+            putMap("paymentMethod", mapFromPaymentMethod(paymentMethod))
+            putBoolean("shouldSavePaymentMethod", shouldSavePaymentMethod)
+          }
+
+        stripeSdkModule.emitOnConfirmHandlerCallback(params)
+
+        val resultFromJavascript = stripeSdkModule.embeddedIntentCreationCallback.await()
+        // reset the completable
+        stripeSdkModule.embeddedIntentCreationCallback = CompletableDeferred()
+
+        resultFromJavascript.getString("clientSecret")?.let {
+          CreateIntentResult.Success(clientSecret = it)
+        } ?: run {
+          val errorMap = resultFromJavascript.getMap("error")
+          CreateIntentResult.Failure(
+            cause = Exception(errorMap?.getString("message")),
+            displayMessage = errorMap?.getString("localizedMessage"),
+          )
+        }
+      },
+      resultCallback = { result ->
+        val map =
+          Arguments.createMap().apply {
+            when (result) {
+              is EmbeddedPaymentElement.Result.Completed -> {
+                putString("status", "completed")
+              }
+              is EmbeddedPaymentElement.Result.Canceled -> {
+                putString("status", "canceled")
+              }
+              is EmbeddedPaymentElement.Result.Failed -> {
+                putString("status", "failed")
+                putString("error", result.error.message ?: "Unknown error")
+              }
+            }
+          }
+        requireStripeSdkModule().emitEmbeddedPaymentElementFormSheetConfirmComplete(map)
+      },
+    )
+  }
+
+  @Composable
+  override fun Content() {
+    val embedded = rememberEmbeddedPaymentElement(builder)
+
+    // collect events: configure, confirm, clear
+    LaunchedEffect(Unit) {
+      events.consumeAsFlow().collect { ev ->
+        when (ev) {
+          is Event.Configure -> {
+            // call configure and grab the result
+            val result =
+              embedded.configure(
+                intentConfiguration = ev.intentConfiguration,
+                configuration = ev.configuration,
+              )
+
+            when (result) {
+              is EmbeddedPaymentElement.ConfigureResult.Succeeded -> {
+                reportHeightChange(450)
+              }
+              is EmbeddedPaymentElement.ConfigureResult.Failed -> {
+                // send the error back to JS
+                val err = result.error
+                val msg = err.localizedMessage ?: err.toString()
+                // build a RN map
+                val payload =
+                  Arguments.createMap().apply {
+                    putString("message", msg)
+                  }
+                requireStripeSdkModule().emitEmbeddedPaymentElementLoadingFailed(payload)
+              }
+            }
+          }
+
+          is Event.Confirm -> {
+            embedded.confirm()
+          }
+          is Event.ClearPaymentOption -> {
+            embedded.clearPaymentOption()
+          }
+        }
+      }
+    }
+
+    LaunchedEffect(embedded) {
+      embedded.paymentOption.collect { opt ->
+        val optMap = opt?.toWritableMap()
+        val payload =
+          Arguments.createMap().apply {
+            putMap("paymentOption", optMap)
+          }
+        requireStripeSdkModule().emitEmbeddedPaymentElementDidUpdatePaymentOption(payload)
+      }
+    }
+
+    embedded.Content()
+  }
+
+  private fun reportHeightChange(height: Int) {
+    val params =
+      Arguments.createMap().apply {
+        putInt("height", height)
+      }
+    requireStripeSdkModule().emitEmbeddedPaymentElementDidUpdateHeight(params)
+  }
+
+  // APIs
+  fun configure(
+    config: EmbeddedPaymentElement.Configuration,
+    intentConfig: PaymentSheet.IntentConfiguration,
+  ) {
+    events.trySend(Event.Configure(config, intentConfig))
+  }
+
+  fun confirm() {
+    events.trySend(Event.Confirm)
+  }
+
+  fun clearPaymentOption() {
+    events.trySend(Event.ClearPaymentOption)
+  }
+
+  private fun requireStripeSdkModule() = requireNotNull(reactContext.getNativeModule(StripeSdkModule::class.java))
+}

package/android/src/main/java/com/reactnativestripesdk/EmbeddedPaymentElementViewManager.kt

@@ -0,0 +1,231 @@
+package com.reactnativestripesdk
+
+import android.annotation.SuppressLint
+import android.content.Context
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.EmbeddedPaymentElementViewManagerDelegate
+import com.facebook.react.viewmanagers.EmbeddedPaymentElementViewManagerInterface
+import com.reactnativestripesdk.PaymentSheetFragment.Companion.buildCustomerConfiguration
+import com.reactnativestripesdk.PaymentSheetFragment.Companion.buildGooglePayConfig
+import com.reactnativestripesdk.addresssheet.AddressSheetView
+import com.reactnativestripesdk.utils.PaymentSheetAppearanceException
+import com.reactnativestripesdk.utils.PaymentSheetException
+import com.reactnativestripesdk.utils.mapToPreferredNetworks
+import com.reactnativestripesdk.utils.toBundleObject
+import com.stripe.android.ExperimentalAllowsRemovalOfLastSavedPaymentMethodApi
+import com.stripe.android.paymentelement.EmbeddedPaymentElement
+import com.stripe.android.paymentelement.ExperimentalEmbeddedPaymentElementApi
+import com.stripe.android.paymentsheet.PaymentSheet
+
+@OptIn(ExperimentalEmbeddedPaymentElementApi::class)
+@ReactModule(name = EmbeddedPaymentElementViewManager.NAME)
+class EmbeddedPaymentElementViewManager :
+  ViewGroupManager<EmbeddedPaymentElementView>(),
+  EmbeddedPaymentElementViewManagerInterface<EmbeddedPaymentElementView> {
+  companion object {
+    const val NAME = "EmbeddedPaymentElementView"
+  }
+
+  private val delegate = EmbeddedPaymentElementViewManagerDelegate(this)
+
+  override fun getName() = NAME
+
+  override fun getDelegate() = delegate
+
+  override fun createViewInstance(ctx: ThemedReactContext): EmbeddedPaymentElementView =
+    EmbeddedPaymentElementView(ctx).apply {
+      setViewCompositionStrategy(
+        ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed,
+      )
+    }
+
+  override fun needsCustomLayoutForChildren(): Boolean = true
+
+  @ReactProp(name = "configuration")
+  override fun setConfiguration(
+    view: EmbeddedPaymentElementView,
+    cfg: Dynamic,
+  ) {
+    val elementConfig = parseElementConfiguration(cfg.asMap(), view.context)
+    view.latestElementConfig = elementConfig
+    // if intentConfig is already set, configure immediately:
+    view.latestIntentConfig?.let { intentCfg ->
+      view.configure(elementConfig, intentCfg)
+      view.post {
+        view.requestLayout()
+        view.invalidate()
+      }
+    }
+  }
+
+  @ReactProp(name = "intentConfiguration")
+  override fun setIntentConfiguration(
+    view: EmbeddedPaymentElementView,
+    cfg: Dynamic,
+  ) {
+    val intentConfig = parseIntentConfiguration(cfg.asMap())
+    view.latestIntentConfig = intentConfig
+    view.latestElementConfig?.let { elemCfg ->
+      view.configure(elemCfg, intentConfig)
+    }
+  }
+
+  @SuppressLint("RestrictedApi")
+  @OptIn(ExperimentalAllowsRemovalOfLastSavedPaymentMethodApi::class)
+  private fun parseElementConfiguration(
+    map: ReadableMap,
+    context: Context,
+  ): EmbeddedPaymentElement.Configuration {
+    val merchantDisplayName = map.getString("merchantDisplayName").orEmpty()
+    val allowsDelayedPaymentMethods = map.getBoolean("allowsDelayedPaymentMethods")
+    var defaultBillingDetails: PaymentSheet.BillingDetails? = null
+    val billingDetailsMap = map.getMap("defaultBillingDetails")
+    if (billingDetailsMap != null) {
+      val addressBundle = billingDetailsMap.getMap("address")
+      val address =
+        PaymentSheet.Address(
+          addressBundle?.getString("city"),
+          addressBundle?.getString("country"),
+          addressBundle?.getString("line1"),
+          addressBundle?.getString("line2"),
+          addressBundle?.getString("postalCode"),
+          addressBundle?.getString("state"),
+        )
+      defaultBillingDetails =
+        PaymentSheet.BillingDetails(
+          address,
+          billingDetailsMap.getString("email"),
+          billingDetailsMap.getString("name"),
+          billingDetailsMap.getString("phone"),
+        )
+    }
+
+    val customerConfiguration =
+      try {
+        buildCustomerConfiguration(toBundleObject(map))
+      } catch (error: PaymentSheetException) {
+        throw Error() // TODO handle error
+      }
+
+    val googlePayConfig = buildGooglePayConfig(toBundleObject(map.getMap("googlePay")))
+    val shippingDetails =
+      map.getMap("defaultShippingDetails")?.let {
+        AddressSheetView.buildAddressDetails(it)
+      }
+    val appearance =
+      try {
+        buildPaymentSheetAppearance(toBundleObject(map.getMap("appearance")), context)
+      } catch (error: PaymentSheetAppearanceException) {
+        throw Error() // TODO handle error
+      }
+    val billingConfigParams = map.getMap("billingDetailsCollectionConfiguration")
+    val billingDetailsConfig =
+      PaymentSheet.BillingDetailsCollectionConfiguration(
+        name = mapToCollectionMode(billingConfigParams?.getString("name")),
+        phone = mapToCollectionMode(billingConfigParams?.getString("phone")),
+        email = mapToCollectionMode(billingConfigParams?.getString("email")),
+        address = mapToAddressCollectionMode(billingConfigParams?.getString("address")),
+        attachDefaultsToPaymentMethod =
+          billingConfigParams?.getBoolean("attachDefaultsToPaymentMethod") ?: false,
+      )
+    val allowsRemovalOfLastSavedPaymentMethod =
+      if (map.hasKey("allowsRemovalOfLastSavedPaymentMethod")) {
+        map.getBoolean("allowsRemovalOfLastSavedPaymentMethod")
+      } else {
+        true
+      }
+    val primaryButtonLabel = map.getString("primaryButtonLabel")
+    val paymentMethodOrder = map.getStringArrayList("paymentMethodOrder")
+
+    val formSheetAction =
+      map
+        .getMap("formSheetAction")
+        ?.getString("type")
+        ?.let { type ->
+          when (type) {
+            "confirm" -> EmbeddedPaymentElement.FormSheetAction.Confirm
+            else -> EmbeddedPaymentElement.FormSheetAction.Continue
+          }
+        }
+        ?: EmbeddedPaymentElement.FormSheetAction.Continue
+
+    val configurationBuilder =
+      EmbeddedPaymentElement.Configuration
+        .Builder(merchantDisplayName)
+        .formSheetAction(formSheetAction)
+        .allowsDelayedPaymentMethods(allowsDelayedPaymentMethods ?: false)
+        .defaultBillingDetails(defaultBillingDetails)
+        .customer(customerConfiguration)
+        .googlePay(googlePayConfig)
+        .appearance(appearance)
+        .shippingDetails(shippingDetails)
+        .billingDetailsCollectionConfiguration(billingDetailsConfig)
+        .preferredNetworks(
+          mapToPreferredNetworks(
+            map
+              .getIntegerArrayList("preferredNetworks")
+              ?.let { ArrayList(it) },
+          ),
+        ).allowsRemovalOfLastSavedPaymentMethod(allowsRemovalOfLastSavedPaymentMethod)
+        .cardBrandAcceptance(mapToCardBrandAcceptance(toBundleObject(map)))
+
+    primaryButtonLabel?.let { configurationBuilder.primaryButtonLabel(it) }
+    paymentMethodOrder?.let { configurationBuilder.paymentMethodOrder(it) }
+
+    return configurationBuilder.build()
+  }
+
+  private fun parseIntentConfiguration(map: ReadableMap): PaymentSheet.IntentConfiguration {
+    val intentConfig = PaymentSheetFragment.buildIntentConfiguration(toBundleObject(map))
+    return intentConfig ?: throw IllegalArgumentException("IntentConfiguration is null")
+  }
+
+  override fun confirm(view: EmbeddedPaymentElementView) {
+    view.confirm()
+  }
+
+  override fun clearPaymentOption(view: EmbeddedPaymentElementView) {
+    view.clearPaymentOption()
+  }
+}
+
+/**
+ * Returns a List of Strings if the key exists and points to an array of strings, or null otherwise.
+ */
+fun ReadableMap.getStringArrayList(key: String): List<String>? {
+  if (!hasKey(key) || getType(key) != ReadableType.Array) return null
+  val array: ReadableArray = getArray(key) ?: return null
+
+  val result = mutableListOf<String>()
+  for (i in 0 until array.size()) {
+    // getString returns null if the element isn't actually a string
+    array.getString(i)?.let { result.add(it) }
+  }
+  return result
+}
+
+/**
+ * Returns a List of Ints if the key exists and points to an array of numbers, or null otherwise.
+ */
+fun ReadableMap.getIntegerArrayList(key: String): List<Int>? {
+  if (!hasKey(key) || getType(key) != ReadableType.Array) return null
+  val array: ReadableArray = getArray(key) ?: return null
+
+  val result = mutableListOf<Int>()
+  for (i in 0 until array.size()) {
+    // getType check to skip non-number entries
+    if (array.getType(i) == ReadableType.Number) {
+      // if it's actually a float/double, this will truncate; adjust as needed
+      result.add(array.getInt(i))
+    }
+  }
+  return result
+}