@stripe/stripe-react-native 0.30.0 → 0.31.1

package/android/src/main/java/com/reactnativestripesdk/customersheet/CustomerSheetFragment.kt

@@ -0,0 +1,329 @@
+package com.reactnativestripesdk
+
+import android.app.Activity
+import android.app.Application
+import android.graphics.drawable.Drawable
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.fragment.app.Fragment
+import com.facebook.react.bridge.*
+import com.reactnativestripesdk.customersheet.ReactNativeCustomerAdapter
+import com.reactnativestripesdk.utils.*
+import com.stripe.android.customersheet.CustomerAdapter
+import com.stripe.android.customersheet.CustomerEphemeralKey
+import com.stripe.android.customersheet.CustomerSheet
+import com.stripe.android.customersheet.CustomerSheetResult
+import com.stripe.android.customersheet.ExperimentalCustomerSheetApi
+import com.stripe.android.customersheet.PaymentOptionSelection
+import com.stripe.android.model.PaymentMethod
+import com.stripe.android.paymentsheet.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+
+@OptIn(ExperimentalCustomerSheetApi::class)
+class CustomerSheetFragment : Fragment() {
+  private var customerSheet: CustomerSheet? = null
+  internal var customerAdapter: ReactNativeCustomerAdapter? = null
+  internal var context: ReactApplicationContext? = null
+  internal var initPromise: Promise? = null
+  private var presentPromise: Promise? = null
+
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?
+  ): View {
+    return FrameLayout(requireActivity()).also {
+      it.visibility = View.GONE
+    }
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+
+    val context = context ?: run {
+      Log.e("StripeReactNative", "No context found during CustomerSheet.initialize. Please file an issue: https://github.com/stripe/stripe-react-native/issues")
+      return
+    }
+    val initPromise = initPromise ?: run {
+      Log.e("StripeReactNative", "No promise found for CustomerSheet.initialize. Please file an issue: https://github.com/stripe/stripe-react-native/issues")
+      return
+    }
+
+    val headerTextForSelectionScreen = arguments?.getString("headerTextForSelectionScreen")
+    val merchantDisplayName = arguments?.getString("merchantDisplayName")
+    val googlePayEnabled = arguments?.getBoolean("googlePayEnabled") ?: false
+    val billingDetailsBundle = arguments?.getBundle("defaultBillingDetails")
+    val billingConfigParams = arguments?.getBundle("billingDetailsCollectionConfiguration")
+    val setupIntentClientSecret = arguments?.getString("setupIntentClientSecret")
+    val customerId = arguments?.getString("customerId")
+    val customerEphemeralKeySecret = arguments?.getString("customerEphemeralKeySecret")
+    val customerAdapterOverrideParams = arguments?.getBundle("customerAdapter")
+
+    if (customerId == null) {
+      initPromise.resolve(createError(ErrorType.Failed.toString(), "You must provide a value for `customerId`"))
+      return
+    }
+    if (customerEphemeralKeySecret == null) {
+      initPromise.resolve(createError(ErrorType.Failed.toString(), "You must provide a value for `customerEphemeralKeySecret`"))
+      return
+    }
+
+    val appearance = try {
+      buildPaymentSheetAppearance(arguments?.getBundle("appearance"), context)
+    } catch (error: PaymentSheetAppearanceException) {
+      initPromise.resolve(createError(ErrorType.Failed.toString(), error))
+      return
+    }
+
+    val configuration = CustomerSheet.Configuration.builder()
+      .appearance(appearance)
+      .googlePayEnabled(googlePayEnabled)
+      .merchantDisplayName(merchantDisplayName)
+      .headerTextForSelectionScreen(headerTextForSelectionScreen)
+
+    billingDetailsBundle?.let {
+      configuration.defaultBillingDetails(createDefaultBillingDetails(billingDetailsBundle))
+    }
+    billingConfigParams?.let {
+      configuration.billingDetailsCollectionConfiguration(createBillingDetailsCollectionConfiguration(billingConfigParams))
+    }
+
+    val customerAdapter = createCustomerAdapter(
+      context, customerId, customerEphemeralKeySecret, setupIntentClientSecret, customerAdapterOverrideParams
+    ).also {
+      this.customerAdapter = it
+    }
+
+    customerSheet = CustomerSheet.create(
+      fragment = this,
+      configuration = configuration.build(),
+      customerAdapter = customerAdapter,
+      callback = ::handleResult
+    )
+
+    initPromise.resolve(WritableNativeMap())
+  }
+
+  private fun handleResult(result: CustomerSheetResult) {
+    val presentPromise = presentPromise ?: run {
+      Log.e("StripeReactNative", "No promise found for CustomerSheet.present")
+      return
+    }
+
+    var promiseResult = Arguments.createMap()
+    when (result) {
+      is CustomerSheetResult.Failed -> {
+        presentPromise.resolve(createError(ErrorType.Failed.toString(), result.exception))
+      }
+      is CustomerSheetResult.Selected -> {
+        promiseResult = createPaymentOptionResult(result.selection)
+      }
+      is CustomerSheetResult.Canceled -> {
+        promiseResult = createPaymentOptionResult(result.selection)
+        promiseResult.putMap("error", Arguments.createMap().also { it.putString("code", ErrorType.Canceled.toString()) })
+      }
+    }
+    presentPromise.resolve(promiseResult)
+  }
+
+  fun present(timeout: Long?, promise: Promise) {
+    presentPromise = promise
+    if (timeout != null) {
+      presentWithTimeout(timeout, promise)
+    }
+    customerSheet?.present() ?: run {
+      promise.resolve(createMissingInitError())
+    }
+  }
+
+  private fun presentWithTimeout(timeout: Long, promise: Promise) {
+    var customerSheetActivity: Activity? = null
+    var activities: MutableList<Activity> = mutableListOf()
+    val activityLifecycleCallbacks = object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
+        customerSheetActivity = activity
+        activities.add(activity)
+      }
+
+      override fun onActivityStarted(activity: Activity) {}
+
+      override fun onActivityResumed(activity: Activity) {}
+
+      override fun onActivityPaused(activity: Activity) {}
+
+      override fun onActivityStopped(activity: Activity) {}
+
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+
+      override fun onActivityDestroyed(activity: Activity) {
+        customerSheetActivity = null
+        activities = mutableListOf()
+        context?.currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
+      }
+    }
+
+      Handler(Looper.getMainLooper()).postDelayed({
+        //customerSheetActivity?.finish()
+        for (a in activities) {
+          a.finish()
+        }
+      }, timeout)
+
+
+    context?.currentActivity?.application?.registerActivityLifecycleCallbacks(activityLifecycleCallbacks)
+
+    customerSheet?.present() ?: run {
+      promise.resolve(createMissingInitError())
+    }
+  }
+
+  internal fun retrievePaymentOptionSelection(promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      runCatching {
+        val result = customerSheet?.retrievePaymentOptionSelection() ?: run {
+          promise.resolve(createMissingInitError())
+          return@launch
+        }
+        var promiseResult = Arguments.createMap()
+        when (result) {
+          is CustomerSheetResult.Failed -> {
+            promise.resolve(createError(ErrorType.Failed.toString(), result.exception))
+          }
+          is CustomerSheetResult.Selected -> {
+            promiseResult = createPaymentOptionResult(result.selection)
+          }
+          is CustomerSheetResult.Canceled -> {
+            promiseResult = createPaymentOptionResult(result.selection)
+            promiseResult.putMap("error", Arguments.createMap().also { it.putString("code", ErrorType.Canceled.toString()) })
+          }
+        }
+        promise.resolve(promiseResult)
+      }.onFailure {
+        promise.resolve(createError(CreateTokenErrorType.Failed.toString(), it.message))
+      }
+    }
+  }
+
+  companion object {
+    internal const val TAG = "customer_sheet_launch_fragment"
+
+    internal fun createMissingInitError(): WritableMap {
+      return createError(ErrorType.Failed.toString(), "No customer sheet has been initialized yet.")
+    }
+
+    internal fun createDefaultBillingDetails(bundle: Bundle): PaymentSheet.BillingDetails {
+      val addressBundle = bundle.getBundle("address")
+      val address = PaymentSheet.Address(
+        addressBundle?.getString("city"),
+        addressBundle?.getString("country"),
+        addressBundle?.getString("line1"),
+        addressBundle?.getString("line2"),
+        addressBundle?.getString("postalCode"),
+        addressBundle?.getString("state"))
+      return PaymentSheet.BillingDetails(
+        address,
+        bundle.getString("email"),
+        bundle.getString("name"),
+        bundle.getString("phone"))
+    }
+
+    internal fun createBillingDetailsCollectionConfiguration(bundle: Bundle): PaymentSheet.BillingDetailsCollectionConfiguration {
+      return PaymentSheet.BillingDetailsCollectionConfiguration(
+        name = mapToCollectionMode(bundle.getString("name")),
+        phone = mapToCollectionMode(bundle.getString("phone")),
+        email = mapToCollectionMode(bundle.getString("email")),
+        address = mapToAddressCollectionMode(bundle.getString("address")),
+        attachDefaultsToPaymentMethod = bundle.getBoolean("attachDefaultsToPaymentMethod")
+      )
+    }
+
+    internal fun createCustomerAdapter(
+      context: ReactApplicationContext,
+      customerId: String,
+      customerEphemeralKeySecret: String,
+      setupIntentClientSecret: String?,
+      customerAdapterOverrideParams: Bundle?,
+    ): ReactNativeCustomerAdapter {
+      val ephemeralKeyProvider = {
+        CustomerAdapter.Result.success(
+          CustomerEphemeralKey.create(
+            customerId = customerId,
+            ephemeralKey = customerEphemeralKeySecret,
+          )
+        )
+      }
+      val customerAdapter = if (setupIntentClientSecret != null) {
+        CustomerAdapter.create(
+          context,
+          customerEphemeralKeyProvider = ephemeralKeyProvider,
+          setupIntentClientSecretProvider = {
+            CustomerAdapter.Result.success(
+              setupIntentClientSecret,
+            )
+          }
+        )
+      } else {
+        CustomerAdapter.create(
+          context,
+          customerEphemeralKeyProvider = ephemeralKeyProvider,
+          setupIntentClientSecretProvider = null
+        )
+      }
+
+      return ReactNativeCustomerAdapter(
+        context = context,
+        adapter = customerAdapter,
+        overridesFetchPaymentMethods = customerAdapterOverrideParams?.getBoolean("fetchPaymentMethods") ?: false,
+        overridesAttachPaymentMethod = customerAdapterOverrideParams?.getBoolean("attachPaymentMethod") ?: false,
+        overridesDetachPaymentMethod = customerAdapterOverrideParams?.getBoolean("detachPaymentMethod") ?: false,
+        overridesSetSelectedPaymentOption = customerAdapterOverrideParams?.getBoolean("setSelectedPaymentOption") ?: false,
+        overridesFetchSelectedPaymentOption = customerAdapterOverrideParams?.getBoolean("fetchSelectedPaymentOption") ?: false,
+        overridesSetupIntentClientSecretForCustomerAttach = customerAdapterOverrideParams?.getBoolean("setupIntentClientSecretForCustomerAttach") ?: false
+      )
+    }
+
+    internal fun createPaymentOptionResult(selection: PaymentOptionSelection?): WritableMap {
+      var paymentOptionResult = Arguments.createMap()
+
+      when (selection) {
+        is PaymentOptionSelection.GooglePay -> {
+          paymentOptionResult = buildResult(
+            selection.paymentOption.label,
+            selection.paymentOption.icon(),
+            null)
+        }
+        is PaymentOptionSelection.PaymentMethod -> {
+          paymentOptionResult = buildResult(
+            selection.paymentOption.label,
+            selection.paymentOption.icon(),
+            selection.paymentMethod)
+        }
+        null -> {}
+      }
+
+      return paymentOptionResult
+    }
+
+    private fun buildResult(label: String, drawable: Drawable, paymentMethod: PaymentMethod?): WritableMap {
+      val result = Arguments.createMap()
+      val paymentOption = Arguments.createMap().also {
+        it.putString("label", label)
+        it.putString("image", getBase64FromBitmap(getBitmapFromDrawable(drawable)))
+      }
+      result.putMap("paymentOption", paymentOption)
+      if (paymentMethod != null) {
+        result.putMap("paymentMethod", mapFromPaymentMethod(paymentMethod))
+      }
+      return result
+    }
+  }
+}

package/android/src/main/java/com/reactnativestripesdk/customersheet/ReactNativeCustomerAdapter.kt

@@ -0,0 +1,138 @@
+package com.reactnativestripesdk.customersheet
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.reactnativestripesdk.StripeSdkModule
+import com.stripe.android.customersheet.CustomerAdapter
+import com.stripe.android.customersheet.ExperimentalCustomerSheetApi
+import com.stripe.android.model.PaymentMethod
+import kotlinx.coroutines.CompletableDeferred
+
+@OptIn(ExperimentalCustomerSheetApi::class)
+class ReactNativeCustomerAdapter (
+  private val context: ReactApplicationContext,
+  private val adapter: CustomerAdapter,
+  private val overridesFetchPaymentMethods: Boolean,
+  private val overridesAttachPaymentMethod: Boolean,
+  private val overridesDetachPaymentMethod: Boolean,
+  private val overridesSetSelectedPaymentOption: Boolean,
+  private val overridesFetchSelectedPaymentOption: Boolean,
+  private val overridesSetupIntentClientSecretForCustomerAttach: Boolean
+) : CustomerAdapter by adapter {
+  internal var fetchPaymentMethodsCallback: CompletableDeferred<List<PaymentMethod>>? = null
+  internal var attachPaymentMethodCallback: CompletableDeferred<PaymentMethod>? = null
+  internal var detachPaymentMethodCallback: CompletableDeferred<PaymentMethod>? = null
+  internal var setSelectedPaymentOptionCallback: CompletableDeferred<Unit>? = null
+  internal var fetchSelectedPaymentOptionCallback: CompletableDeferred<String?>? = null
+  internal var setupIntentClientSecretForCustomerAttachCallback: CompletableDeferred<String>? = null
+
+  override suspend fun retrievePaymentMethods(): CustomerAdapter.Result<List<PaymentMethod>> {
+    if (overridesFetchPaymentMethods) {
+      CompletableDeferred<List<PaymentMethod>>().also {
+        fetchPaymentMethodsCallback = it
+        emitEvent("onCustomerAdapterFetchPaymentMethodsCallback", Arguments.createMap())
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(resultFromJavascript)
+      }
+    }
+
+    return adapter.retrievePaymentMethods()
+  }
+
+  override suspend fun attachPaymentMethod(paymentMethodId: String): CustomerAdapter.Result<PaymentMethod> {
+    if (overridesAttachPaymentMethod) {
+      CompletableDeferred<PaymentMethod>().also {
+        attachPaymentMethodCallback = it
+        val params = Arguments.createMap().also {
+          it.putString("paymentMethodId", paymentMethodId)
+        }
+        emitEvent("onCustomerAdapterAttachPaymentMethodCallback", params)
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(resultFromJavascript)
+      }
+    }
+
+    return adapter.attachPaymentMethod(paymentMethodId)
+  }
+
+  override suspend fun detachPaymentMethod(paymentMethodId: String): CustomerAdapter.Result<PaymentMethod> {
+    if (overridesDetachPaymentMethod) {
+      CompletableDeferred<PaymentMethod>().also {
+        detachPaymentMethodCallback = it
+        val params = Arguments.createMap().also {
+          it.putString("paymentMethodId", paymentMethodId)
+        }
+        emitEvent("onCustomerAdapterDetachPaymentMethodCallback", params)
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(resultFromJavascript)
+      }
+    }
+
+    return adapter.detachPaymentMethod(paymentMethodId)
+  }
+
+  override suspend fun setSelectedPaymentOption(paymentOption: CustomerAdapter.PaymentOption?): CustomerAdapter.Result<Unit> {
+    if (overridesSetSelectedPaymentOption) {
+      CompletableDeferred<Unit>().also {
+        setSelectedPaymentOptionCallback = it
+        val params = Arguments.createMap().also {
+          it.putString("paymentOption", paymentOption?.id)
+        }
+        emitEvent("onCustomerAdapterSetSelectedPaymentOptionCallback", params)
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(resultFromJavascript)
+      }
+    }
+
+    return adapter.setSelectedPaymentOption(paymentOption)
+  }
+
+  override suspend fun retrieveSelectedPaymentOption(): CustomerAdapter.Result<CustomerAdapter.PaymentOption?> {
+    if (overridesFetchSelectedPaymentOption) {
+      CompletableDeferred<String?>().also {
+        fetchSelectedPaymentOptionCallback = it
+        emitEvent("onCustomerAdapterFetchSelectedPaymentOptionCallback", Arguments.createMap())
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(
+          if (resultFromJavascript != null) {
+            CustomerAdapter.PaymentOption.fromId(resultFromJavascript)
+          } else {
+            null
+          }
+        )
+      }
+    }
+
+    return adapter.retrieveSelectedPaymentOption()
+  }
+
+  override suspend fun setupIntentClientSecretForCustomerAttach(): CustomerAdapter.Result<String> {
+    if (overridesSetupIntentClientSecretForCustomerAttach) {
+      CompletableDeferred<String>().also {
+        setupIntentClientSecretForCustomerAttachCallback = it
+        emitEvent("onCustomerAdapterSetupIntentClientSecretForCustomerAttachCallback", Arguments.createMap())
+        val resultFromJavascript = it.await()
+        return CustomerAdapter.Result.success(resultFromJavascript)
+      }
+    }
+
+    return adapter.setupIntentClientSecretForCustomerAttach()
+  }
+
+  private fun emitEvent(eventName: String, params: WritableMap) {
+    val stripeSdkModule: StripeSdkModule? = context.getNativeModule(StripeSdkModule::class.java)
+    if (stripeSdkModule == null || stripeSdkModule.eventListenerCount == 0) {
+      Log.e(
+        "StripeReactNative",
+        "Tried to call $eventName, but no callback was found. Please file an issue: https://github.com/stripe/stripe-react-native/issues"
+      )
+    }
+
+    stripeSdkModule?.sendEvent(context, eventName, params)
+  }
+}
+
+

package/android/src/main/java/com/reactnativestripesdk/utils/Mappers.kt

@@ -850,9 +850,15 @@ fun toBundleObject(readableMap: ReadableMap?): Bundle {
       ReadableType.Null -> result.putString(key, null)
       ReadableType.Boolean -> result.putBoolean(key, readableMap.getBoolean(key))
       ReadableType.Number -> try {
-        result.putInt(key, readableMap.getInt(key))
+        val numAsInt = readableMap.getInt(key)
+        val numAsDouble = readableMap.getDouble(key)
+        if (numAsDouble - numAsInt != 0.0) {
+          result.putDouble(key, numAsDouble)
+        } else {
+          result.putInt(key, numAsInt)
+        }
       } catch (e: Exception) {
-        result.putDouble(key, readableMap.getDouble(key))
+        Log.e("toBundleException", "Failed to add number to bundle. Failed on: $key.")
       }
       ReadableType.String -> result.putString(key, readableMap.getString(key))
       ReadableType.Map -> result.putBundle(key, toBundleObject(readableMap.getMap(key)))

package/ios/CustomerSheet/CustomerSheetUtils.swift

@@ -0,0 +1,181 @@
+//
+//  CustomerSheetUtils.swift
+//  stripe-react-native
+//
+//  Created by Charles Cruzan on 08/28/23.
+//
+
+import Foundation
+@_spi(PrivateBetaCustomerSheet) import StripePaymentSheet
+
+class CustomerSheetUtils {
+    internal class func buildCustomerSheetConfiguration(
+        appearance: PaymentSheet.Appearance,
+        style: PaymentSheet.UserInterfaceStyle,
+        removeSavedPaymentMethodMessage: String?,
+        returnURL: String?,
+        headerTextForSelectionScreen: String?,
+        applePayEnabled: Bool?,
+        merchantDisplayName: String?,
+        billingDetailsCollectionConfiguration: NSDictionary?,
+        defaultBillingDetails: NSDictionary?
+    ) -> CustomerSheet.Configuration {
+        var config = CustomerSheet.Configuration()
+        config.appearance = appearance
+        config.style = style
+        config.removeSavedPaymentMethodMessage = removeSavedPaymentMethodMessage
+        config.returnURL = returnURL
+        config.headerTextForSelectionScreen = headerTextForSelectionScreen
+        config.applePayEnabled = applePayEnabled ?? false
+        if let merchantDisplayName = merchantDisplayName {
+            config.merchantDisplayName = merchantDisplayName
+        }
+        if let billingConfigParams = billingDetailsCollectionConfiguration {
+            config.billingDetailsCollectionConfiguration.name = StripeSdk.mapToCollectionMode(str: billingConfigParams["name"] as? String)
+            config.billingDetailsCollectionConfiguration.phone = StripeSdk.mapToCollectionMode(str: billingConfigParams["phone"] as? String)
+            config.billingDetailsCollectionConfiguration.email = StripeSdk.mapToCollectionMode(str: billingConfigParams["email"] as? String)
+            config.billingDetailsCollectionConfiguration.address = StripeSdk.mapToAddressCollectionMode(str: billingConfigParams["address"] as? String)
+            config.billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod = billingConfigParams["attachDefaultsToPaymentMethod"] as? Bool == true
+        }
+        if let defaultBillingDetails = defaultBillingDetails {
+            config.defaultBillingDetails.name = defaultBillingDetails["name"] as? String
+            config.defaultBillingDetails.email = defaultBillingDetails["email"] as? String
+            config.defaultBillingDetails.phone = defaultBillingDetails["phone"] as? String
+            if let address = defaultBillingDetails["address"] as? [String: String] {
+                config.defaultBillingDetails.address = .init(city: address["city"],
+                                                          country: address["country"],
+                                                            line1: address["line1"],
+                                                            line2: address["line2"],
+                                                       postalCode: address["postalCode"],
+                                                            state: address["state"])
+            }
+        }
+        return config
+    }
+    
+    internal class func buildStripeCustomerAdapter(
+        customerId: String,
+        ephemeralKeySecret: String,
+        setupIntentClientSecret: String?,
+        customerAdapter: NSDictionary,
+        stripeSdk: StripeSdk
+    ) -> StripeCustomerAdapter {
+        if (customerAdapter.count > 0) {
+            return buildCustomerAdapterOverride(
+                customerAdapter: customerAdapter,
+                customerId: customerId,
+                ephemeralKeySecret: ephemeralKeySecret,
+                setupIntentClientSecret: setupIntentClientSecret,
+                stripeSdk: stripeSdk
+            )
+        }
+        
+        if let setupIntentClientSecret = setupIntentClientSecret {
+            return StripeCustomerAdapter(
+                customerEphemeralKeyProvider: {
+                    return CustomerEphemeralKey(customerId: customerId, ephemeralKeySecret: ephemeralKeySecret)
+                },
+                setupIntentClientSecretProvider: {
+                    return setupIntentClientSecret
+                }
+            )
+        }
+
+        return StripeCustomerAdapter(
+            customerEphemeralKeyProvider: {
+                return CustomerEphemeralKey(customerId: customerId, ephemeralKeySecret: ephemeralKeySecret)
+            }
+        )
+    }
+    
+    internal class func buildCustomerAdapterOverride(
+        customerAdapter: NSDictionary,
+        customerId: String,
+        ephemeralKeySecret: String,
+        setupIntentClientSecret: String?,
+        stripeSdk: StripeSdk
+    ) -> StripeCustomerAdapter {
+        return ReactNativeCustomerAdapter(
+            fetchPaymentMethods: customerAdapter["fetchPaymentMethods"] as? Bool ?? false,
+            attachPaymentMethod: customerAdapter["attachPaymentMethod"] as? Bool ?? false,
+            detachPaymentMethod: customerAdapter["detachPaymentMethod"] as? Bool ?? false,
+            setSelectedPaymentOption: customerAdapter["setSelectedPaymentOption"] as? Bool ?? false,
+            fetchSelectedPaymentOption: customerAdapter["fetchSelectedPaymentOption"] as? Bool ?? false,
+            setupIntentClientSecretForCustomerAttach: customerAdapter["setupIntentClientSecretForCustomerAttach"] as? Bool ?? false,
+            customerId: customerId,
+            ephemeralKeySecret: ephemeralKeySecret,
+            setupIntentClientSecret: setupIntentClientSecret,
+            stripeSdk: stripeSdk
+        )
+    }
+
+    internal class func getModalPresentationStyle(_ string: String?) -> UIModalPresentationStyle {
+        switch (string) {
+        case "fullscreen":
+            return .fullScreen
+        case "popover":
+            fallthrough
+        default:
+            return .popover
+        }
+    }
+
+    internal class func getModalTransitionStyle(_ string: String?) -> UIModalTransitionStyle {
+        switch (string) {
+        case "flip":
+            return .flipHorizontal
+        case "curl":
+            return .partialCurl
+        case "dissolve":
+            return .crossDissolve
+        case "slide":
+            fallthrough
+        default:
+            return .coverVertical
+        }
+    }
+
+    
+    internal class func buildPaymentOptionResult(label: String, imageData: String?, paymentMethod: STPPaymentMethod?) -> NSMutableDictionary {
+        let result: NSMutableDictionary = [:]
+        let paymentOption: NSMutableDictionary = [:]
+        paymentOption.setValue(label, forKey: "label")
+        if (imageData != nil) {
+            paymentOption.setValue(imageData, forKey: "image")
+        }
+        result.setValue(paymentOption, forKey: "paymentOption")
+        if (paymentMethod != nil) {
+            result.setValue(Mappers.mapFromPaymentMethod(paymentMethod), forKey: "paymentMethod")
+        }
+        return result
+    }
+    
+    internal class func interpretResult(result: CustomerSheet.CustomerSheetResult) -> NSDictionary {
+        var payload: NSMutableDictionary = [:]
+        switch result {
+        case .error(let error):
+            return Errors.createError(ErrorType.Failed, error as NSError)
+        case .selected(let paymentOption):
+            switch paymentOption {
+            case .applePay(let paymentOptionDisplayData):
+                payload = CustomerSheetUtils.buildPaymentOptionResult(label: paymentOptionDisplayData.label, imageData: paymentOptionDisplayData.image.pngData()?.base64EncodedString(), paymentMethod: nil)
+            case .paymentMethod(let paymentMethod, let paymentOptionDisplayData):
+                payload = CustomerSheetUtils.buildPaymentOptionResult(label: paymentOptionDisplayData.label, imageData: paymentOptionDisplayData.image.pngData()?.base64EncodedString(), paymentMethod: paymentMethod)
+            case .none:
+                break
+            }
+        case .canceled(let paymentOption):
+            switch paymentOption {
+            case .applePay(let paymentOptionDisplayData):
+                payload = CustomerSheetUtils.buildPaymentOptionResult(label: paymentOptionDisplayData.label, imageData: paymentOptionDisplayData.image.pngData()?.base64EncodedString(), paymentMethod: nil)
+            case .paymentMethod(let paymentMethod, let paymentOptionDisplayData):
+                payload = CustomerSheetUtils.buildPaymentOptionResult(label: paymentOptionDisplayData.label, imageData: paymentOptionDisplayData.image.pngData()?.base64EncodedString(), paymentMethod: paymentMethod)
+            case .none:
+                break
+            }
+            payload.setValue(["code": ErrorType.Canceled], forKey: "error")
+        }
+        return payload
+    }
+
+}