@stripe/stripe-react-native 0.57.0 → 0.57.2

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

@@ -0,0 +1,228 @@
+package com.reactnativestripesdk
+
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativestripesdk.utils.PaymentSheetException
+import com.reactnativestripesdk.utils.getBooleanOr
+import com.reactnativestripesdk.utils.getIntOr
+import com.reactnativestripesdk.utils.getLongOr
+import com.reactnativestripesdk.utils.getStringList
+import com.reactnativestripesdk.utils.isEmpty
+import com.stripe.android.paymentelement.PaymentMethodOptionsSetupFutureUsagePreview
+import com.stripe.android.paymentsheet.PaymentSheet
+
+@Throws(PaymentSheetException::class)
+internal fun buildIntentConfiguration(intentConfigurationParams: ReadableMap?): PaymentSheet.IntentConfiguration? {
+  if (intentConfigurationParams == null) {
+    return null
+  }
+  val modeParams =
+    intentConfigurationParams.getMap("mode")
+      ?: throw PaymentSheetException(
+        "If `intentConfiguration` is provided, `intentConfiguration.mode` is required",
+      )
+
+  return PaymentSheet.IntentConfiguration(
+    mode = buildIntentConfigurationMode(modeParams),
+    paymentMethodTypes =
+      intentConfigurationParams.getStringList("paymentMethodTypes")?.toList()
+        ?: emptyList(),
+    onBehalfOf = intentConfigurationParams.getString("onBehalfOf"),
+  )
+}
+
+@OptIn(PaymentMethodOptionsSetupFutureUsagePreview::class)
+private fun buildIntentConfigurationMode(modeParams: ReadableMap): PaymentSheet.IntentConfiguration.Mode =
+  if (modeParams.hasKey("amount")) {
+    val currencyCode =
+      modeParams.getString("currencyCode")
+        ?: throw PaymentSheetException(
+          "You must provide a value to intentConfiguration.mode.currencyCode",
+        )
+    PaymentSheet.IntentConfiguration.Mode.Payment(
+      amount = modeParams.getLongOr("amount", 0),
+      currency = currencyCode,
+      setupFutureUse = mapToSetupFutureUse(modeParams.getString("setupFutureUsage")),
+      captureMethod = mapToCaptureMethod(modeParams.getString("captureMethod")),
+      paymentMethodOptions = mapToPaymentMethodOptions(modeParams.getMap("paymentMethodOptions")),
+    )
+  } else {
+    val setupFutureUsage =
+      mapToSetupFutureUse(modeParams.getString("setupFutureUsage"))
+        ?: throw PaymentSheetException(
+          "You must provide a value to intentConfiguration.mode.setupFutureUsage",
+        )
+    PaymentSheet.IntentConfiguration.Mode.Setup(
+      currency = modeParams.getString("currencyCode"),
+      setupFutureUse = setupFutureUsage,
+    )
+  }
+
+internal fun buildLinkConfig(params: ReadableMap?): PaymentSheet.LinkConfiguration {
+  if (params == null) {
+    return PaymentSheet.LinkConfiguration()
+  }
+
+  val display = mapStringToLinkDisplay(params.getString("display"))
+
+  return PaymentSheet.LinkConfiguration(
+    display = display,
+  )
+}
+
+private fun mapStringToLinkDisplay(value: String?): PaymentSheet.LinkConfiguration.Display =
+  when (value) {
+    "automatic" -> PaymentSheet.LinkConfiguration.Display.Automatic
+    "never" -> PaymentSheet.LinkConfiguration.Display.Never
+    else -> PaymentSheet.LinkConfiguration.Display.Automatic
+  }
+
+private val mapIntToButtonType =
+  mapOf(
+    1 to PaymentSheet.GooglePayConfiguration.ButtonType.Buy,
+    6 to PaymentSheet.GooglePayConfiguration.ButtonType.Book,
+    5 to PaymentSheet.GooglePayConfiguration.ButtonType.Checkout,
+    4 to PaymentSheet.GooglePayConfiguration.ButtonType.Donate,
+    11 to PaymentSheet.GooglePayConfiguration.ButtonType.Order,
+    1000 to PaymentSheet.GooglePayConfiguration.ButtonType.Pay,
+    7 to PaymentSheet.GooglePayConfiguration.ButtonType.Subscribe,
+    1001 to PaymentSheet.GooglePayConfiguration.ButtonType.Plain,
+  )
+
+internal fun buildGooglePayConfig(params: ReadableMap?): PaymentSheet.GooglePayConfiguration? {
+  if (params == null || params.isEmpty()) {
+    return null
+  }
+
+  val countryCode = params.getString("merchantCountryCode").orEmpty()
+  val currencyCode = params.getString("currencyCode").orEmpty()
+  val testEnv = params.getBooleanOr("testEnv", false)
+  val amount = params.getString("amount")?.toLongOrNull()
+  val label = params.getString("label")
+  val buttonType =
+    mapIntToButtonType[params.getIntOr("buttonType", 0)]
+      ?: PaymentSheet.GooglePayConfiguration.ButtonType.Pay
+
+  return PaymentSheet.GooglePayConfiguration(
+    environment =
+      if (testEnv) {
+        PaymentSheet.GooglePayConfiguration.Environment.Test
+      } else {
+        PaymentSheet.GooglePayConfiguration.Environment.Production
+      },
+    countryCode = countryCode,
+    currencyCode = currencyCode,
+    amount = amount,
+    label = label,
+    buttonType = buttonType,
+  )
+}
+
+@Throws(PaymentSheetException::class)
+internal fun buildCustomerConfiguration(map: ReadableMap?): PaymentSheet.CustomerConfiguration? {
+  val customerId = map?.getString("customerId").orEmpty()
+  val customerEphemeralKeySecret = map?.getString("customerEphemeralKeySecret").orEmpty()
+  val customerSessionClientSecret = map?.getString("customerSessionClientSecret").orEmpty()
+  return if (customerSessionClientSecret.isNotEmpty() &&
+    customerEphemeralKeySecret.isNotEmpty()
+  ) {
+    throw PaymentSheetException(
+      "`customerEphemeralKeySecret` and `customerSessionClientSecret` cannot both be set",
+    )
+  } else if (customerId.isNotEmpty() && customerSessionClientSecret.isNotEmpty()) {
+    PaymentSheet.CustomerConfiguration.createWithCustomerSession(
+      id = customerId,
+      clientSecret = customerSessionClientSecret,
+    )
+  } else if (customerId.isNotEmpty() && customerEphemeralKeySecret.isNotEmpty()) {
+    PaymentSheet.CustomerConfiguration(
+      id = customerId,
+      ephemeralKeySecret = customerEphemeralKeySecret,
+    )
+  } else {
+    null
+  }
+}
+
+internal fun buildBillingDetails(map: ReadableMap?): PaymentSheet.BillingDetails? {
+  if (map == null) {
+    return null
+  }
+  val addressMap = map.getMap("address")
+  val address =
+    PaymentSheet.Address(
+      addressMap?.getString("city"),
+      addressMap?.getString("country"),
+      addressMap?.getString("line1"),
+      addressMap?.getString("line2"),
+      addressMap?.getString("postalCode"),
+      addressMap?.getString("state"),
+    )
+  return PaymentSheet.BillingDetails(
+    address,
+    map.getString("email"),
+    map.getString("name"),
+    map.getString("phone"),
+  )
+}
+
+internal fun buildBillingDetailsCollectionConfiguration(map: ReadableMap?): PaymentSheet.BillingDetailsCollectionConfiguration =
+  PaymentSheet.BillingDetailsCollectionConfiguration(
+    name = mapToCollectionMode(map?.getString("name")),
+    phone = mapToCollectionMode(map?.getString("phone")),
+    email = mapToCollectionMode(map?.getString("email")),
+    address = mapToAddressCollectionMode(map?.getString("address")),
+    attachDefaultsToPaymentMethod = map.getBooleanOr("attachDefaultsToPaymentMethod", false),
+  )
+
+internal fun mapToCollectionMode(str: String?): PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode =
+  when (str) {
+    "automatic" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Automatic
+    "never" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Never
+    "always" -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Always
+    else -> PaymentSheet.BillingDetailsCollectionConfiguration.CollectionMode.Automatic
+  }
+
+internal fun mapToAddressCollectionMode(str: String?): PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode =
+  when (str) {
+    "automatic" ->
+      PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Automatic
+
+    "never" -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Never
+    "full" -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Full
+    else -> PaymentSheet.BillingDetailsCollectionConfiguration.AddressCollectionMode.Automatic
+  }
+
+internal fun mapToCardBrandAcceptance(params: ReadableMap?): PaymentSheet.CardBrandAcceptance {
+  val cardBrandAcceptanceParams = params?.getMap("cardBrandAcceptance") ?: return PaymentSheet.CardBrandAcceptance.all()
+  val filter = cardBrandAcceptanceParams.getString("filter") ?: return PaymentSheet.CardBrandAcceptance.all()
+
+  return when (filter) {
+    "all" -> PaymentSheet.CardBrandAcceptance.all()
+    "allowed" -> {
+      val brands = cardBrandAcceptanceParams.getStringList("brands") ?: return PaymentSheet.CardBrandAcceptance.all()
+      val brandCategories = brands.mapNotNull { mapToCardBrandCategory(it) }
+      if (brandCategories.isEmpty()) {
+        return PaymentSheet.CardBrandAcceptance.all()
+      }
+      PaymentSheet.CardBrandAcceptance.allowed(brandCategories)
+    }
+    "disallowed" -> {
+      val brands = cardBrandAcceptanceParams.getStringList("brands") ?: return PaymentSheet.CardBrandAcceptance.all()
+      val brandCategories = brands.mapNotNull { mapToCardBrandCategory(it) }
+      if (brandCategories.isEmpty()) {
+        return PaymentSheet.CardBrandAcceptance.all()
+      }
+      PaymentSheet.CardBrandAcceptance.disallowed(brandCategories)
+    }
+    else -> PaymentSheet.CardBrandAcceptance.all()
+  }
+}
+
+internal fun mapToCardBrandCategory(brand: String): PaymentSheet.CardBrandAcceptance.BrandCategory? =
+  when (brand) {
+    "visa" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Visa
+    "mastercard" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Mastercard
+    "amex" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Amex
+    "discover" -> PaymentSheet.CardBrandAcceptance.BrandCategory.Discover
+    else -> null
+  }

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

@@ -342,6 +342,7 @@ class PaymentLauncherManager(
       StripeIntent.NextActionType.DisplayOxxoDetails,
       StripeIntent.NextActionType.DisplayBoletoDetails,
       StripeIntent.NextActionType.DisplayKonbiniDetails,
+      StripeIntent.NextActionType.DisplayPayNowDetails,
       StripeIntent.NextActionType.VerifyWithMicrodeposits,
       StripeIntent.NextActionType.DisplayMultibancoDetails,
       StripeIntent.NextActionType.DisplayPayNowDetails,

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

@@ -6,6 +6,7 @@ import com.reactnativestripesdk.utils.getValOr
 import com.reactnativestripesdk.utils.mapToBillingDetails
 import com.reactnativestripesdk.utils.mapToMetadata
 import com.reactnativestripesdk.utils.mapToPaymentIntentFutureUsage
+import com.reactnativestripesdk.utils.mapToShippingDetails
 import com.reactnativestripesdk.utils.mapToUSBankAccountHolderType
 import com.reactnativestripesdk.utils.mapToUSBankAccountType
 import com.stripe.android.model.ConfirmPaymentIntentParams
@@ -403,10 +404,12 @@ class PaymentMethodCreateParamsFactory(
     }
 
     val params = createAffirmParams()
+    val shippingDetails = mapToShippingDetails(paymentMethodData?.getMap("shippingDetails"))
 
     return ConfirmPaymentIntentParams.createWithPaymentMethodCreateParams(
       paymentMethodCreateParams = params,
       clientSecret = clientSecret,
+      shipping = shippingDetails,
       setupFutureUsage = mapToPaymentIntentFutureUsage(getValOr(options, "setupFutureUsage")),
       mandateData = buildMandateDataParams(),
     )

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

@@ -11,8 +11,6 @@ import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.TextUnit
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
-import com.reactnativestripesdk.getBase64FromBitmap
-import com.reactnativestripesdk.getBitmapFromDrawable
 import com.reactnativestripesdk.utils.mapFromPaymentSheetBillingDetails
 import com.stripe.android.paymentelement.EmbeddedPaymentElement
 import kotlinx.coroutines.Dispatchers
@@ -50,7 +48,7 @@ suspend fun EmbeddedPaymentElement.PaymentOptionDisplayData.toWritableMap(): Wri
             getBase64FromBitmap(bitmap)
           } ?: ""
         }
-      } catch (e: Exception) {
+      } catch (_: Exception) {
         // If imageLoader fails or times out, return empty string
         ""
       }
@@ -120,17 +118,17 @@ fun AnnotatedString.toHtmlString(): String {
           }
         }
         AnnotationType.STRING_ANNOTATION -> {
-          val stringAnnotation = annotation.data as AnnotatedString.Range<String>
+          val stringAnnotation = annotation.data as AnnotatedString.Range<*>
           when (stringAnnotation.tag) {
             "URL", "LINK_TAG" -> {
               val url = stringAnnotation.item
-              htmlBuilder.append("<a href=\"${escapeHtml(url)}\">")
+              htmlBuilder.append("<a href=\"${escapeHtml(url as String)}\">")
               openTags.add(TagInfo(annotation.end, "</a>"))
             }
           }
         }
         AnnotationType.LINK_ANNOTATION -> {
-          val linkAnnotation = annotation.data as AnnotatedString.Range<LinkAnnotation>
+          val linkAnnotation = annotation.data as AnnotatedString.Range<*>
           when (val linkItem = linkAnnotation.item) {
             is LinkAnnotation.Url -> {
               htmlBuilder.append("<a href=\"${escapeHtml(linkItem.url)}\">")

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

@@ -3,7 +3,7 @@ package com.reactnativestripesdk
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.res.Configuration
-import android.graphics.Color
+import androidx.core.graphics.toColorInt
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
@@ -34,8 +34,8 @@ fun buildPaymentSheetAppearance(
 
   val builder = PaymentSheet.Appearance.Builder()
   builder.typography(buildTypography(userParams?.getMap(PaymentSheetAppearanceKeys.FONT), context))
-  builder.colorsLight(buildColorsBuilder(lightColorParams).buildLight())
-  builder.colorsDark(buildColorsBuilder(darkColorParams).buildDark())
+  builder.colorsLight(buildColorsBuilder(isLightMode = true, lightColorParams).build())
+  builder.colorsDark(buildColorsBuilder(isLightMode = false, darkColorParams).build())
   builder.shapes(buildShapes(userParams?.getMap(PaymentSheetAppearanceKeys.SHAPES)))
   builder.primaryButton(
     buildPrimaryButton(
@@ -48,6 +48,7 @@ fun buildPaymentSheetAppearance(
   return builder.build()
 }
 
+@SuppressLint("RestrictedApi")
 @OptIn(AppearanceAPIAdditionsPreview::class)
 private fun buildTypography(
   fontParams: ReadableMap?,
@@ -74,7 +75,7 @@ private fun buildTypography(
 private fun colorFromHex(hexString: String?): Int? =
   hexString?.trim()?.replace("#", "")?.let {
     if (it.length == 6 || it.length == 8) {
-      Color.parseColor("#$it")
+      "#$it".toColorInt()
     } else {
       throw PaymentSheetAppearanceException(
         "Failed to set Payment Sheet appearance. Expected hex string of length 6 or 8, but received: $it",
@@ -82,8 +83,17 @@ private fun colorFromHex(hexString: String?): Int? =
     }
   }
 
-private fun buildColorsBuilder(colorParams: ReadableMap?): PaymentSheet.Colors.Builder {
-  val builder = PaymentSheet.Colors.Builder()
+@SuppressLint("RestrictedApi")
+private fun buildColorsBuilder(
+  isLightMode: Boolean,
+  colorParams: ReadableMap?,
+): PaymentSheet.Colors.Builder {
+  val builder =
+    if (isLightMode) {
+      PaymentSheet.Colors.Builder.light()
+    } else {
+      PaymentSheet.Colors.Builder.dark()
+    }
 
   colorFromHex(colorParams?.getString(PaymentSheetAppearanceKeys.PRIMARY))?.let {
     builder.primary(it)
@@ -132,6 +142,7 @@ private fun buildColorsBuilder(colorParams: ReadableMap?): PaymentSheet.Colors.B
   return builder
 }
 
+@SuppressLint("RestrictedApi")
 private fun buildShapes(shapeParams: ReadableMap?): PaymentSheet.Shapes {
   val builder = PaymentSheet.Shapes.Builder()
 
@@ -146,6 +157,7 @@ private fun buildShapes(shapeParams: ReadableMap?): PaymentSheet.Shapes {
   return builder.build()
 }
 
+@SuppressLint("RestrictedApi")
 private fun buildPrimaryButton(
   params: ReadableMap?,
   context: Context,
@@ -162,9 +174,9 @@ private fun buildPrimaryButton(
 
   return PaymentSheet.PrimaryButton(
     colorsLight =
-      buildPrimaryButtonColors(lightColorParams, context).buildLight(),
+      buildPrimaryButtonColors(true, lightColorParams, context).build(),
     colorsDark =
-      buildPrimaryButtonColors(darkColorParams, context).buildDark(),
+      buildPrimaryButtonColors(false, darkColorParams, context).build(),
     shape =
       PaymentSheet.PrimaryButtonShape(
         cornerRadiusDp =
@@ -181,12 +193,19 @@ private fun buildPrimaryButton(
   )
 }
 
+@SuppressLint("RestrictedApi")
 @Throws(PaymentSheetAppearanceException::class)
 private fun buildPrimaryButtonColors(
+  isLightMode: Boolean,
   colorParams: ReadableMap,
   context: Context,
 ): PaymentSheet.PrimaryButtonColors.Builder {
-  val builder = PaymentSheet.PrimaryButtonColors.Builder()
+  val builder =
+    if (isLightMode) {
+      PaymentSheet.PrimaryButtonColors.Builder.light()
+    } else {
+      PaymentSheet.PrimaryButtonColors.Builder.dark()
+    }
 
   // TODO: Why is background a string but successBackgroundColor a "dynamic" color?
   // https://stripe.dev/stripe-react-native/api-reference/types/PaymentSheet.PrimaryButtonColorConfig.html
@@ -236,16 +255,23 @@ private fun buildEmbeddedAppearance(
       val separatorInsetsParams =
         flatParams?.getMap(PaymentSheetAppearanceKeys.SEPARATOR_INSETS)
 
-      val flatRadioColorsBuilder =
+      val flatRadioLightColorsBuilder =
         PaymentSheet.Appearance.Embedded.RowStyle.FlatWithRadio.Colors
-          .Builder()
+          .Builder
+          .light()
+
+      val flatRadioDarkColorsBuilder =
+        PaymentSheet.Appearance.Embedded.RowStyle.FlatWithRadio.Colors
+          .Builder
+          .dark()
 
       dynamicColorFromParams(
         context,
         flatParams,
         PaymentSheetAppearanceKeys.SEPARATOR_COLOR,
       )?.let {
-        flatRadioColorsBuilder.separatorColor(it)
+        flatRadioLightColorsBuilder.separatorColor(it)
+        flatRadioDarkColorsBuilder.separatorColor(it)
       }
 
       dynamicColorFromParams(
@@ -253,7 +279,8 @@ private fun buildEmbeddedAppearance(
         radioParams,
         PaymentSheetAppearanceKeys.SELECTED_COLOR,
       )?.let {
-        flatRadioColorsBuilder.selectedColor(it)
+        flatRadioLightColorsBuilder.selectedColor(it)
+        flatRadioDarkColorsBuilder.selectedColor(it)
       }
 
       dynamicColorFromParams(
@@ -261,7 +288,8 @@ private fun buildEmbeddedAppearance(
         radioParams,
         PaymentSheetAppearanceKeys.UNSELECTED_COLOR,
       )?.let {
-        flatRadioColorsBuilder.unselectedColor(it)
+        flatRadioLightColorsBuilder.unselectedColor(it)
+        flatRadioDarkColorsBuilder.unselectedColor(it)
       }
 
       val rowStyleBuilder =
@@ -292,32 +320,39 @@ private fun buildEmbeddedAppearance(
         rowStyleBuilder.additionalVerticalInsetsDp(it)
       }
 
-      rowStyleBuilder.colorsLight(flatRadioColorsBuilder.buildLight())
-      rowStyleBuilder.colorsDark(flatRadioColorsBuilder.buildDark())
+      rowStyleBuilder.colorsLight(flatRadioLightColorsBuilder.build())
+      rowStyleBuilder.colorsDark(flatRadioDarkColorsBuilder.build())
 
       embeddedBuilder.rowStyle(rowStyleBuilder.build())
     }
 
     "flatWithCheckmark" -> {
-      val flatParams = rowParams?.getMap(PaymentSheetAppearanceKeys.FLAT)
+      val flatParams = rowParams.getMap(PaymentSheetAppearanceKeys.FLAT)
       val checkmarkParams = flatParams?.getMap(PaymentSheetAppearanceKeys.CHECKMARK)
       val separatorInsetsParams =
         flatParams?.getMap(PaymentSheetAppearanceKeys.SEPARATOR_INSETS)
 
-      val flatCheckmarkColorsBuilder =
+      val flatCheckmarkLightColorsBuilder =
         PaymentSheet.Appearance.Embedded.RowStyle.FlatWithCheckmark.Colors
-          .Builder()
+          .Builder
+          .light()
+      val flatCheckmarkDarkColorsBuilder =
+        PaymentSheet.Appearance.Embedded.RowStyle.FlatWithCheckmark.Colors
+          .Builder
+          .dark()
 
       dynamicColorFromParams(
         context,
         flatParams,
         PaymentSheetAppearanceKeys.SEPARATOR_COLOR,
       )?.let {
-        flatCheckmarkColorsBuilder.separatorColor(it)
+        flatCheckmarkLightColorsBuilder.separatorColor(it)
+        flatCheckmarkDarkColorsBuilder.separatorColor(it)
       }
 
       dynamicColorFromParams(context, checkmarkParams, PaymentSheetAppearanceKeys.COLOR)?.let {
-        flatCheckmarkColorsBuilder.checkmarkColor(it)
+        flatCheckmarkLightColorsBuilder.checkmarkColor(it)
+        flatCheckmarkDarkColorsBuilder.checkmarkColor(it)
       }
 
       val rowStyleBuilder =
@@ -353,31 +388,38 @@ private fun buildEmbeddedAppearance(
       }
 
       // TODO: The theme is so crazy long, why does each Color thing has the same redundant Theme...
-      rowStyleBuilder.colorsLight(flatCheckmarkColorsBuilder.buildLight())
-      rowStyleBuilder.colorsDark(flatCheckmarkColorsBuilder.buildDark())
+      rowStyleBuilder.colorsLight(flatCheckmarkLightColorsBuilder.build())
+      rowStyleBuilder.colorsDark(flatCheckmarkDarkColorsBuilder.build())
       embeddedBuilder.rowStyle(rowStyleBuilder.build())
     }
 
     "flatWithDisclosure" -> {
-      val flatParams = rowParams?.getMap(PaymentSheetAppearanceKeys.FLAT)
+      val flatParams = rowParams.getMap(PaymentSheetAppearanceKeys.FLAT)
       val disclosureParams = flatParams?.getMap(PaymentSheetAppearanceKeys.DISCLOSURE)
       val separatorInsetsParams =
         flatParams?.getMap(PaymentSheetAppearanceKeys.SEPARATOR_INSETS)
 
-      val flatDisclosureColorsBuilder =
+      val flatDisclosureLightColorsBuilder =
         PaymentSheet.Appearance.Embedded.RowStyle.FlatWithDisclosure.Colors
-          .Builder()
+          .Builder
+          .light()
+      val flatDisclosureDarkColorsBuilder =
+        PaymentSheet.Appearance.Embedded.RowStyle.FlatWithDisclosure.Colors
+          .Builder
+          .dark()
 
       dynamicColorFromParams(
         context,
         flatParams,
         PaymentSheetAppearanceKeys.SEPARATOR_COLOR,
       )?.let {
-        flatDisclosureColorsBuilder.separatorColor(it)
+        flatDisclosureLightColorsBuilder.separatorColor(it)
+        flatDisclosureDarkColorsBuilder.separatorColor(it)
       }
 
       dynamicColorFromParams(context, disclosureParams, PaymentSheetAppearanceKeys.COLOR)?.let {
-        flatDisclosureColorsBuilder.disclosureColor(it)
+        flatDisclosureLightColorsBuilder.disclosureColor(it)
+        flatDisclosureDarkColorsBuilder.disclosureColor(it)
       }
 
       val rowStyleBuilder =
@@ -408,8 +450,8 @@ private fun buildEmbeddedAppearance(
         rowStyleBuilder.additionalVerticalInsetsDp(it)
       }
 
-      rowStyleBuilder.colorsLight(flatDisclosureColorsBuilder.buildLight())
-      rowStyleBuilder.colorsDark(flatDisclosureColorsBuilder.buildDark())
+      rowStyleBuilder.colorsLight(flatDisclosureLightColorsBuilder.build())
+      rowStyleBuilder.colorsDark(flatDisclosureDarkColorsBuilder.build())
 
       embeddedBuilder.rowStyle(rowStyleBuilder.build())
     }
@@ -516,6 +558,7 @@ private fun getFontResId(
     )
   }
 
+  @SuppressLint("DiscouragedApi")
   val id = context.resources.getIdentifier(fontFileName, "font", context.packageName)
   if (id == 0) {
     throw PaymentSheetAppearanceException("$fontErrorPrefix Failed to find font: $fontFileName")