@stripe/stripe-react-native 0.65.0 → 0.66.0

package/android/src/test/java/com/reactnativestripesdk/utils/CheckoutTestFixtures.java

@@ -0,0 +1,57 @@
+package com.reactnativestripesdk.utils;
+
+import com.stripe.android.checkout.CheckoutSession;
+import com.stripe.android.paymentsheet.verticalmode.CurrencySelectorOptions;
+import java.util.Arrays;
+import java.util.Collections;
+
+public final class CheckoutTestFixtures {
+  private CheckoutTestFixtures() {}
+
+  public static CheckoutSession fullSession() {
+    CheckoutSession.TotalSummary totals =
+        new CheckoutSession.TotalSummary(
+            5000L,
+            4044L,
+            4044L,
+            Arrays.asList(
+                new CheckoutSession.DiscountAmount(500L, "SUMMER10"),
+                new CheckoutSession.DiscountAmount(250L, "LOYALTY5")),
+            Collections.singletonList(
+                new CheckoutSession.TaxAmount(294L, false, "Sales Tax", 6.875d)),
+            new CheckoutSession.ShippingRate(
+                "shr_standard", 500L, "Standard Shipping", "5-7 business days"),
+            null);
+
+    return new CheckoutSession(
+        "cs_test_123",
+        CheckoutSession.Status.Open,
+        false,
+        "usd",
+        null,
+        new CheckoutSession.Tax(CheckoutSession.Tax.Status.Ready),
+        totals,
+        Arrays.asList(
+            new CheckoutSession.LineItem("li_item1", "Llama Figure", 2, null, 1998L, 1998L),
+            new CheckoutSession.LineItem("li_item2", "Alpaca Plushie", 1, 2499L, 2499L, 2499L)),
+        Arrays.asList(
+            new CheckoutSession.ShippingRate("shr_standard", 500L, "Standard Shipping", null),
+            new CheckoutSession.ShippingRate(
+                "shr_express", 1500L, "Express Shipping", "1-2 business days")),
+        (CurrencySelectorOptions) null);
+  }
+
+  public static CheckoutSession blankCurrencySession() {
+    return new CheckoutSession(
+        "cs_test_blank_currency",
+        CheckoutSession.Status.Open,
+        false,
+        "",
+        null,
+        new CheckoutSession.Tax(CheckoutSession.Tax.Status.Ready),
+        null,
+        Collections.<CheckoutSession.LineItem>emptyList(),
+        Collections.<CheckoutSession.ShippingRate>emptyList(),
+        (CurrencySelectorOptions) null);
+  }
+}

package/ios/ConnectAccountOnboarding/ConnectAccountOnboardingViewController.swift

@@ -122,12 +122,10 @@ class ConnectAccountOnboardingViewController: UIViewController {
         reactContentView?.layoutIfNeeded()
     }
 
-    override func viewWillDisappear(_ animated: Bool) {
-        super.viewWillDisappear(animated)
-
-        // If being dismissed (not just going to background), notify
-        if isBeingDismissed {
-            onClose?()
-        }
-    }
+    // No viewWillDisappear/isBeingDismissed handler here. The modal uses .fullScreen
+    // presentation which prevents swipe-to-dismiss, so the only user-initiated exit path
+    // is the close button (handleCloseButtonPressed). Adding isBeingDismissed here would
+    // cause spurious onExit events when iOS presents a child VC (e.g. ASWebAuthenticationSession
+    // for identity verification) over this modal — UIKit calls viewWillDisappear and reports
+    // isBeingDismissed = true even though the user didn't close the modal.
 }

package/ios/CurrencySelectorElementManager.m

@@ -0,0 +1,16 @@
+//
+//  CurrencySelectorElementManager.m
+//  stripe-react-native
+//
+//  Created by Nick Porter on 5/7/26.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(StripeCurrencySelectorElementManager, RCTViewManager)
+RCT_EXPORT_VIEW_PROPERTY(sessionKey, NSString)
+RCT_EXPORT_VIEW_PROPERTY(disabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(onHeightChange, RCTDirectEventBlock)
+@end

package/ios/CurrencySelectorElementView.swift

@@ -0,0 +1,159 @@
+//
+//  CurrencySelectorElementView.swift
+//  stripe-react-native
+//
+//  Created by Nick Porter on 5/7/26.
+//
+
+import Combine
+import Foundation
+@_spi(ReactNativeSDK) import StripePaymentSheet
+import UIKit
+
+@objc(StripeCurrencySelectorElementManager)
+class StripeCurrencySelectorElementManager: RCTViewManager {
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override func view() -> UIView! {
+        return StripeCurrencySelectorElementContainerView(frame: .zero)
+    }
+}
+
+@objc(StripeCurrencySelectorElementContainerView)
+public class StripeCurrencySelectorElementContainerView: UIView {
+
+    // MARK: - Bridge-exposed Props
+
+    @objc public var sessionKey: String? {
+        didSet {
+            guard sessionKey != oldValue else { return }
+            attachToSessionIfPossible()
+        }
+    }
+
+    @objc public var disabled: Bool = false {
+        didSet {
+            selectorView?.isEnabled = !disabled
+        }
+    }
+
+    /// Fired whenever the inner selector's intrinsic height changes so RN
+    /// can match it. Session-state changes flow through the central
+    /// `checkoutSessionDidChangeState` event on `StripeSdk` (see
+    /// `CheckoutStateBridge`), so this view does not need to push state.
+    @objc public var onHeightChange: RCTDirectEventBlock?
+
+    // MARK: - Private Properties
+
+    private var selectorView: Checkout.CurrencySelectorView?
+    private var sessionCancellable: AnyCancellable?
+    private var lastReportedHeight: CGFloat = -1
+
+    // MARK: - Init
+
+    override public init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .clear
+        clipsToBounds = true
+    }
+
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    // MARK: - Layout
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        reportHeightIfNeeded()
+    }
+
+    // MARK: - Setup
+
+    private func attachToSessionIfPossible() {
+        Task { @MainActor in
+            guard let key = self.sessionKey,
+                  let checkout = StripeSdkImpl.shared.checkoutInstances[key] else {
+                self.detach()
+                return
+            }
+
+            // Already showing a selector — leave it in place. Re-creating
+            // would interrupt the inner view's loading animation and reset
+            // its enabled state mid-API-call.
+            if self.selectorView != nil {
+                return
+            }
+
+            self.installSelectorView(for: checkout)
+            self.subscribeForLayoutUpdates(on: checkout)
+        }
+    }
+
+    /// We don't push state to JS here — `CheckoutStateBridge` already does
+    /// that for the whole session. This subscription only nudges Auto Layout
+    /// so the caption-text changes after a currency selection are reflected
+    /// in our reported height back to RN.
+    private func subscribeForLayoutUpdates(on checkout: Checkout) {
+        sessionCancellable = checkout.$state
+            .dropFirst()
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                guard let self else { return }
+                self.setNeedsLayout()
+                self.layoutIfNeeded()
+                self.reportHeightIfNeeded()
+            }
+    }
+
+    private func installSelectorView(for checkout: Checkout) {
+        let view = Checkout.CurrencySelectorView(checkout: checkout)
+        view.translatesAutoresizingMaskIntoConstraints = false
+        view.isEnabled = !disabled
+        addSubview(view)
+
+        NSLayoutConstraint.activate([
+            view.topAnchor.constraint(equalTo: topAnchor),
+            view.leadingAnchor.constraint(equalTo: leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: trailingAnchor),
+            view.bottomAnchor.constraint(equalTo: bottomAnchor),
+        ])
+
+        selectorView = view
+
+        // Force an initial height report so RN can lay us out at zero
+        // when Adaptive Pricing is unavailable.
+        setNeedsLayout()
+        layoutIfNeeded()
+    }
+
+    private func detach() {
+        sessionCancellable?.cancel()
+        sessionCancellable = nil
+        selectorView?.removeFromSuperview()
+        selectorView = nil
+        lastReportedHeight = -1
+    }
+
+    // MARK: - Events
+
+    private func reportHeightIfNeeded() {
+        let desiredHeight: CGFloat
+        if let selectorView, !selectorView.isHidden {
+            desiredHeight = selectorView.systemLayoutSizeFitting(
+                CGSize(width: bounds.width, height: UIView.layoutFittingCompressedSize.height),
+                withHorizontalFittingPriority: .required,
+                verticalFittingPriority: .fittingSizeLevel
+            ).height
+        } else {
+            desiredHeight = 0
+        }
+
+        guard desiredHeight != lastReportedHeight else { return }
+        lastReportedHeight = desiredHeight
+        onHeightChange?(["height": desiredHeight])
+    }
+}

package/ios/EmbeddedPaymentElementView.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-@_spi(EmbeddedPaymentElementPrivateBeta) import StripePaymentSheet
+import StripePaymentSheet
 import UIKit
 
 @objc(EmbeddedPaymentElementView)

package/ios/Mappers+Checkout.swift

@@ -0,0 +1,337 @@
+//
+//  Mappers+Checkout.swift
+//  stripe-react-native
+//
+//  Created by Nick Porter on 4/29/26.
+//
+
+import Foundation
+@_spi(ReactNativeSDK) import StripePaymentSheet
+
+extension Mappers {
+
+    // MARK: - State & Session
+
+    class func mapFromCheckoutState(_ state: Checkout.State) -> NSDictionary {
+        [
+            "status": state.isLoading ? "loading" : "loaded",
+            "session": mapFromCheckoutSession(state.session),
+        ]
+    }
+
+    class func mapFromCheckoutSession(_ session: Checkout.Session) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["id"] = session.id
+        result["livemode"] = session.livemode
+        result["lineItems"] = session.lineItems.map(mapFromLineItem)
+        result["shippingOptions"] = session.shippingOptions.map(mapFromShippingOption)
+        result["discountAmounts"] = session.discountAmounts.map(mapFromDiscountAmount)
+        result["currencyOptions"] = session.currencyOptions.map(mapFromCurrencyOption)
+        result["tax"] = mapFromTax(session.tax)
+
+        if let businessName = session.businessName {
+            result["businessName"] = businessName
+        }
+        if let currency = session.currency {
+            result["currency"] = currency
+        }
+        if let email = session.email {
+            result["email"] = email
+        }
+        if let minorUnitsAmountDivisor = session.minorUnitsAmountDivisor {
+            result["minorUnitsAmountDivisor"] = minorUnitsAmountDivisor
+        }
+        if let status = session.status {
+            result["status"] = mapFromStatus(status)
+        }
+        if let total = session.total {
+            result["total"] = mapFromTotal(total)
+        }
+        if let shipping = session.shipping {
+            result["shipping"] = mapFromSelectedShipping(shipping)
+        }
+        if let billingAddress = session.billingAddress {
+            result["billingAddress"] = mapFromContactAddress(billingAddress)
+        }
+        if let shippingAddress = session.shippingAddress {
+            result["shippingAddress"] = mapFromContactAddress(shippingAddress)
+        }
+
+        return result
+    }
+
+    // MARK: - Amount
+
+    class func mapFromAmount(_ amount: Checkout.Amount) -> NSDictionary {
+        [
+            "amount": amount.amount,
+            "minorUnitsAmount": amount.minorUnitsAmount,
+        ]
+    }
+
+    class func mapFromDecimalAmount(_ decimalAmount: Checkout.DecimalAmount) -> NSDictionary {
+        [
+            "amount": decimalAmount.amount,
+            "minorUnitsAmount": NSDecimalNumber(decimal: decimalAmount.minorUnitsAmount).doubleValue,
+        ]
+    }
+
+    // MARK: - Status
+
+    class func mapFromStatus(_ status: Checkout.Status) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["type"] = mapFromStatusType(status.type)
+
+        if let paymentStatus = status.paymentStatus {
+            result["paymentStatus"] = mapFromPaymentStatus(paymentStatus)
+        }
+
+        return result
+    }
+
+    private class func mapFromStatusType(_ type: Checkout.StatusType) -> String {
+        switch type {
+        case .open: return "open"
+        case .complete: return "complete"
+        case .expired: return "expired"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private class func mapFromPaymentStatus(_ paymentStatus: Checkout.PaymentStatus) -> String {
+        switch paymentStatus {
+        case .paid: return "paid"
+        case .unpaid: return "unpaid"
+        case .noPaymentRequired: return "noPaymentRequired"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
+    }
+
+    // MARK: - Total
+
+    class func mapFromTotal(_ total: Checkout.Total) -> NSDictionary {
+        [
+            "subtotal": mapFromAmount(total.subtotal),
+            "taxExclusive": mapFromAmount(total.taxExclusive),
+            "taxInclusive": mapFromAmount(total.taxInclusive),
+            "shippingRate": mapFromAmount(total.shippingRate),
+            "discount": mapFromAmount(total.discount),
+            "total": mapFromAmount(total.total),
+            "appliedBalance": mapFromAmount(total.appliedBalance),
+            "balanceAppliedToNextInvoice": total.balanceAppliedToNextInvoice,
+        ]
+    }
+
+    // MARK: - Tax
+
+    class func mapFromTax(_ tax: Checkout.Tax) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["status"] = mapFromTaxStatus(tax.status)
+
+        if let taxAmounts = tax.taxAmounts {
+            result["taxAmounts"] = taxAmounts.map(mapFromTaxAmount)
+        }
+
+        return result
+    }
+
+    private class func mapFromTaxStatus(_ status: Checkout.TaxStatus) -> String {
+        switch status {
+        case .ready: return "ready"
+        case .requiresShippingAddress: return "requiresShippingAddress"
+        case .requiresBillingAddress: return "requiresBillingAddress"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
+    }
+
+    private class func mapFromTaxAmount(_ taxAmount: Checkout.TaxAmount) -> NSDictionary {
+        [
+            "amount": mapFromAmount(taxAmount.amount),
+            "inclusive": taxAmount.inclusive,
+            "displayName": taxAmount.displayName,
+        ]
+    }
+
+    // MARK: - Line Items
+
+    class func mapFromLineItem(_ lineItem: Checkout.LineItem) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["id"] = lineItem.id
+        result["name"] = lineItem.name
+        result["images"] = lineItem.images
+        result["quantity"] = lineItem.quantity
+        result["discountAmounts"] = lineItem.discountAmounts.map(mapFromDiscountAmount)
+        result["taxAmounts"] = lineItem.taxAmounts.map(mapFromTaxAmount)
+
+        if let description = lineItem.description {
+            result["description"] = description
+        }
+        if let unitAmount = lineItem.unitAmount {
+            result["unitAmount"] = mapFromAmount(unitAmount)
+        }
+        if let unitAmountDecimal = lineItem.unitAmountDecimal {
+            result["unitAmountDecimal"] = mapFromDecimalAmount(unitAmountDecimal)
+        }
+        if let subtotal = lineItem.subtotal {
+            result["subtotal"] = mapFromAmount(subtotal)
+        }
+        if let discount = lineItem.discount {
+            result["discount"] = mapFromAmount(discount)
+        }
+        if let taxExclusive = lineItem.taxExclusive {
+            result["taxExclusive"] = mapFromAmount(taxExclusive)
+        }
+        if let taxInclusive = lineItem.taxInclusive {
+            result["taxInclusive"] = mapFromAmount(taxInclusive)
+        }
+        if let total = lineItem.total {
+            result["total"] = mapFromAmount(total)
+        }
+        if let adjustableQuantity = lineItem.adjustableQuantity {
+            result["adjustableQuantity"] = mapFromAdjustableQuantity(adjustableQuantity)
+        }
+
+        return result
+    }
+
+    private class func mapFromAdjustableQuantity(_ adjustableQuantity: Checkout.AdjustableQuantity) -> NSDictionary {
+        [
+            "minimum": adjustableQuantity.minimum,
+            "maximum": adjustableQuantity.maximum,
+        ]
+    }
+
+    // MARK: - Shipping
+
+    class func mapFromShippingOption(_ shippingOption: Checkout.ShippingOption) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["id"] = shippingOption.id
+        result["amount"] = mapFromAmount(shippingOption.amount)
+        result["currency"] = shippingOption.currency
+
+        if let displayName = shippingOption.displayName {
+            result["displayName"] = displayName
+        }
+        if let deliveryEstimate = shippingOption.deliveryEstimate {
+            result["deliveryEstimate"] = mapFromDeliveryEstimate(deliveryEstimate)
+        }
+
+        return result
+    }
+
+    private class func mapFromDeliveryEstimate(_ estimate: Checkout.DeliveryEstimate) -> NSDictionary {
+        let result = NSMutableDictionary()
+
+        if let minimum = estimate.minimum {
+            result["minimum"] = mapFromDeliveryEstimateBound(minimum)
+        }
+        if let maximum = estimate.maximum {
+            result["maximum"] = mapFromDeliveryEstimateBound(maximum)
+        }
+
+        return result
+    }
+
+    private class func mapFromDeliveryEstimateBound(_ bound: Checkout.DeliveryEstimate.Bound) -> NSDictionary {
+        [
+            "unit": mapFromDeliveryEstimateUnit(bound.unit),
+            "value": bound.value,
+        ]
+    }
+
+    private class func mapFromDeliveryEstimateUnit(_ unit: Checkout.DeliveryEstimate.Bound.Unit) -> String {
+        switch unit {
+        case .hour: return "hour"
+        case .day: return "day"
+        case .businessDay: return "businessDay"
+        case .week: return "week"
+        case .month: return "month"
+        case .unknown: return "unknown"
+        @unknown default: return "unknown"
+        }
+    }
+
+    class func mapFromSelectedShipping(_ selectedShipping: Checkout.SelectedShipping) -> NSDictionary {
+        [
+            "shippingOption": mapFromShippingOption(selectedShipping.shippingOption),
+            "taxAmounts": selectedShipping.taxAmounts.map(mapFromTaxAmount),
+        ]
+    }
+
+    // MARK: - Discounts
+
+    class func mapFromDiscountAmount(_ discountAmount: Checkout.DiscountAmount) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["amount"] = mapFromAmount(discountAmount.amount)
+        result["displayName"] = discountAmount.displayName
+
+        if let promotionCode = discountAmount.promotionCode {
+            result["promotionCode"] = promotionCode
+        }
+
+        return result
+    }
+
+    // MARK: - Currency Options
+
+    class func mapFromCurrencyOption(_ currencyOption: Checkout.CurrencyOption) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["amount"] = mapFromAmount(currencyOption.amount)
+        result["currency"] = currencyOption.currency
+
+        if let currencyConversion = currencyOption.currencyConversion {
+            result["currencyConversion"] = mapFromCurrencyConversion(currencyConversion)
+        }
+
+        return result
+    }
+
+    private class func mapFromCurrencyConversion(_ conversion: Checkout.CurrencyConversion) -> NSDictionary {
+        [
+            "fxRate": conversion.fxRate,
+            "sourceCurrency": conversion.sourceCurrency,
+        ]
+    }
+
+    // MARK: - Address
+
+    class func mapFromContactAddress(_ contactAddress: Checkout.ContactAddress) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["address"] = mapFromCheckoutAddress(contactAddress.address)
+
+        if let name = contactAddress.name {
+            result["name"] = name
+        }
+        if let phone = contactAddress.phone {
+            result["phone"] = phone
+        }
+
+        return result
+    }
+
+    private class func mapFromCheckoutAddress(_ address: Checkout.Address) -> NSDictionary {
+        let result = NSMutableDictionary()
+        result["country"] = address.country
+
+        if let line1 = address.line1 {
+            result["line1"] = line1
+        }
+        if let line2 = address.line2 {
+            result["line2"] = line2
+        }
+        if let city = address.city {
+            result["city"] = city
+        }
+        if let state = address.state {
+            result["state"] = state
+        }
+        if let postalCode = address.postalCode {
+            result["postalCode"] = postalCode
+        }
+
+        return result
+    }
+}