@stripe/stripe-react-native 0.65.0 → 0.66.0

package/ios/StripeSdkImpl+Checkout.swift

@@ -0,0 +1,360 @@
+//
+//  StripeSdkImpl+Checkout.swift
+//  stripe-react-native
+//
+//  Created by Nick Porter on 4/29/26.
+//
+
+import Combine
+import Foundation
+@_spi(ReactNativeSDK) import StripePaymentSheet
+
+extension StripeSdkImpl {
+    internal func currentCheckoutStateResult(checkout: Checkout) -> NSDictionary {
+        Mappers.mapFromCheckoutState(checkout.state)
+    }
+
+    @objc(initCheckoutSession:configuration:resolver:rejecter:)
+    public func initCheckoutSession(
+        clientSecret: String,
+        configuration: NSDictionary,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let checkoutConfiguration = buildCheckoutConfiguration(params: configuration)
+
+        Task { @MainActor [weak self] in
+            guard let self else {
+                reject(ErrorType.Failed, "Stripe SDK is unavailable", nil)
+                return
+            }
+
+            do {
+                let checkout = try await Checkout(
+                    clientSecret: clientSecret,
+                    configuration: checkoutConfiguration
+                )
+                let sessionKey = UUID().uuidString
+
+                let cancellable = checkout.$state
+                    .dropFirst()
+                    .sink { [weak self] state in
+                        self?.emitter?.emitCheckoutSessionDidChangeState([
+                            "sessionKey": sessionKey,
+                            "state": Mappers.mapFromCheckoutState(state),
+                        ])
+                    }
+
+                self.checkoutInstances[sessionKey] = checkout
+                self.checkoutStateCancellables[sessionKey] = cancellable
+
+                resolve([
+                    "sessionKey": sessionKey,
+                    "state": self.currentCheckoutStateResult(checkout: checkout),
+                ])
+            } catch {
+                reject(self.checkoutErrorCode(for: error), error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(checkoutUpdateShippingAddress:address:name:phone:resolver:rejecter:)
+    public func checkoutUpdateShippingAddress(
+        sessionKey: String,
+        address: NSDictionary,
+        name: String?,
+        phone: String?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutAddressMutation(
+            sessionKey: sessionKey,
+            address: address,
+            name: name,
+            phone: phone,
+            missingCountryMessage: "A shipping address country is required.",
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout, addressUpdate in
+            try await checkout.updateShippingAddress(
+                name: addressUpdate.name,
+                phone: addressUpdate.phone,
+                address: addressUpdate.address
+            )
+        }
+    }
+
+    @objc(checkoutUpdateBillingAddress:address:name:phone:resolver:rejecter:)
+    public func checkoutUpdateBillingAddress(
+        sessionKey: String,
+        address: NSDictionary,
+        name: String?,
+        phone: String?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutAddressMutation(
+            sessionKey: sessionKey,
+            address: address,
+            name: name,
+            phone: phone,
+            missingCountryMessage: "A billing address country is required.",
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout, addressUpdate in
+            try await checkout.updateBillingAddress(
+                name: addressUpdate.name,
+                phone: addressUpdate.phone,
+                address: addressUpdate.address
+            )
+        }
+    }
+
+    @objc(checkoutApplyPromotionCode:code:resolver:rejecter:)
+    public func checkoutApplyPromotionCode(
+        sessionKey: String,
+        code: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await checkout.applyPromotionCode(code)
+        }
+    }
+
+    @objc(checkoutRemovePromotionCode:resolver:rejecter:)
+    public func checkoutRemovePromotionCode(
+        sessionKey: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await checkout.removePromotionCode()
+        }
+    }
+
+    @objc(checkoutUpdateLineItemQuantity:lineItemId:quantity:resolver:rejecter:)
+    public func checkoutUpdateLineItemQuantity(
+        sessionKey: String,
+        lineItemId: String,
+        quantity: Double,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard quantity.isFinite, let integerQuantity = Int(exactly: quantity) else {
+            reject(ErrorType.Failed, "Line item quantity must be an integer.", nil)
+            return
+        }
+
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await checkout.updateQuantity(lineItemId: lineItemId, quantity: integerQuantity)
+        }
+    }
+
+    @objc(checkoutSelectShippingOption:id:resolver:rejecter:)
+    public func checkoutSelectShippingOption(
+        sessionKey: String,
+        id: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await checkout.selectShippingOption(id)
+        }
+    }
+
+    @objc(checkoutUpdateTaxId:type:value:resolver:rejecter:)
+    public func checkoutUpdateTaxId(
+        sessionKey: String,
+        type: String,
+        value: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await checkout.updateTaxId(type: type, value: value)
+        }
+    }
+
+    @objc(checkoutRunServerUpdateStart:resolver:rejecter:)
+    public func checkoutRunServerUpdateStart(
+        sessionKey: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        Task { @MainActor [weak self] in
+            guard let self else {
+                reject(ErrorType.Failed, "Stripe SDK is unavailable", nil)
+                return
+            }
+
+            guard let checkout = self.checkoutInstances[sessionKey] else {
+                reject(ErrorType.Failed, "Checkout session not found", nil)
+                return
+            }
+
+            guard self.serverUpdateContinuations[sessionKey] == nil else {
+                reject(ErrorType.Failed, "A server update is already in progress for this session", nil)
+                return
+            }
+
+            do {
+                try await checkout.runServerUpdate {
+                    try await withCheckedThrowingContinuation { continuation in
+                        self.serverUpdateContinuations[sessionKey] = continuation
+                    }
+                }
+                resolve(self.currentCheckoutStateResult(checkout: checkout))
+            } catch {
+                reject(self.checkoutErrorCode(for: error), error.localizedDescription, error)
+            }
+        }
+    }
+
+    @objc(checkoutRunServerUpdateComplete:error:resolver:rejecter:)
+    public func checkoutRunServerUpdateComplete(
+        sessionKey: String,
+        error: String?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard let continuation = serverUpdateContinuations.removeValue(forKey: sessionKey) else {
+            reject(ErrorType.Failed, "No pending server update for this session", nil)
+            return
+        }
+
+        if let error {
+            continuation.resume(throwing: CheckoutError.apiError(message: error))
+        } else {
+            continuation.resume()
+        }
+        resolve(nil)
+    }
+
+    internal func buildCheckoutConfiguration(params: NSDictionary) -> Checkout.Configuration {
+        var configuration = Checkout.Configuration()
+
+        if let adaptivePricing = params["adaptivePricing"] as? NSDictionary,
+           let allowed = adaptivePricing["allowed"] as? Bool {
+            configuration.adaptivePricing.allowed = allowed
+        }
+
+        return configuration
+    }
+
+    private func performCheckoutMutation(
+        sessionKey: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock,
+        operation: @escaping (Checkout) async throws -> Void
+    ) {
+        Task { @MainActor [weak self] in
+            guard let self else {
+                reject(ErrorType.Failed, "Stripe SDK is unavailable", nil)
+                return
+            }
+
+            guard let checkout = self.checkoutInstances[sessionKey] else {
+                reject(ErrorType.Failed, "Checkout session not found", nil)
+                return
+            }
+
+            do {
+                try await operation(checkout)
+                resolve(self.currentCheckoutStateResult(checkout: checkout))
+            } catch {
+                reject(self.checkoutErrorCode(for: error), error.localizedDescription, error)
+            }
+        }
+    }
+
+    private func performCheckoutAddressMutation(
+        sessionKey: String,
+        address: NSDictionary,
+        name: String?,
+        phone: String?,
+        missingCountryMessage: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock,
+        operation: @escaping (Checkout, Checkout.ContactAddress) async throws -> Void
+    ) {
+        guard let addressUpdate = buildCheckoutAddressUpdate(
+            address: address,
+            name: name,
+            phone: phone
+        ) else {
+            reject(ErrorType.Failed, missingCountryMessage, nil)
+            return
+        }
+
+        performCheckoutMutation(
+            sessionKey: sessionKey,
+            resolver: resolve,
+            rejecter: reject
+        ) { checkout in
+            try await operation(checkout, addressUpdate)
+        }
+    }
+
+    private func buildCheckoutAddressUpdate(
+        address: NSDictionary,
+        name: String?,
+        phone: String?
+    ) -> Checkout.ContactAddress? {
+        guard let country = address["country"] as? String, !country.isEmpty else {
+            return nil
+        }
+
+        let checkoutAddress = Checkout.Address(
+            country: country,
+            line1: address["line1"] as? String,
+            line2: address["line2"] as? String,
+            city: address["city"] as? String,
+            state: address["state"] as? String,
+            postalCode: address["postalCode"] as? String
+        )
+
+        return Checkout.ContactAddress(
+            name: name,
+            phone: phone,
+            address: checkoutAddress
+        )
+    }
+
+    private func checkoutErrorCode(for error: Error) -> String {
+        if let checkoutError = error as? CheckoutError {
+            switch checkoutError {
+            case .invalidClientSecret:
+                return "InvalidClientSecret"
+            case .sessionNotOpen:
+                return "SessionNotOpen"
+            case .sheetCurrentlyPresented:
+                return "SheetCurrentlyPresented"
+            default:
+                return ErrorType.Failed
+            }
+        }
+
+        return ErrorType.Failed
+    }
+}

package/ios/StripeSdkImpl+CustomerSheet.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-@_spi(PrivateBetaCustomerSheet) @_spi(CustomerSessionBetaAccess) @_spi(STP) import StripePaymentSheet
+@_spi(PrivateBetaCustomerSheet) @_spi(STP) import StripePaymentSheet
 extension StripeSdkImpl {
     @objc(initCustomerSheet:customerAdapterOverrides:resolver:rejecter:)
     public func initCustomerSheet(params: NSDictionary,

package/ios/StripeSdkImpl+Embedded.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-@_spi(EmbeddedPaymentElementPrivateBeta) @_spi(ExperimentalAllowsRemovalOfLastSavedPaymentMethodAPI) @_spi(CustomerSessionBetaAccess) @_spi(STP) @_spi(CustomPaymentMethodsBeta) @_spi(CardFundingFilteringPrivatePreview) import StripePaymentSheet
+@_spi(ExperimentalAllowsRemovalOfLastSavedPaymentMethodAPI) @_spi(STP) @_spi(CustomPaymentMethodsBeta) @_spi(CardFundingFilteringPrivatePreview) import StripePaymentSheet
 
 @objc(StripeSdkImpl)
 extension StripeSdkImpl {
@@ -19,19 +19,22 @@ extension StripeSdkImpl {
                                            resolve: @escaping RCTPromiseResolveBlock,
                                            reject: @escaping RCTPromiseRejectBlock) {
     guard let modeParams = intentConfig["mode"] as? NSDictionary else {
-      resolve(Errors.createError(ErrorType.Failed, "One of `paymentIntentClientSecret`, `setupIntentClientSecret`, or `intentConfiguration.mode` is required"))
+      emitLoadingFailed(message: "One of `paymentIntentClientSecret`, `setupIntentClientSecret`, or `intentConfiguration.mode` is required")
+      resolve(nil)
       return
     }
     let hasConfirmHandler = intentConfig.object(forKey: "confirmHandler") != nil
     let hasConfirmationTokenHandler = intentConfig.object(forKey: "confirmationTokenConfirmHandler") != nil
 
     if !hasConfirmHandler && !hasConfirmationTokenHandler {
-      resolve(Errors.createError(ErrorType.Failed, "You must provide either `intentConfiguration.confirmHandler` or `intentConfiguration.confirmationTokenConfirmHandler` if you are not passing an intent client secret"))
+      emitLoadingFailed(message: "You must provide either `intentConfiguration.confirmHandler` or `intentConfiguration.confirmationTokenConfirmHandler` if you are not passing an intent client secret")
+      resolve(nil)
       return
     }
 
     if hasConfirmHandler && hasConfirmationTokenHandler {
-      resolve(Errors.createError(ErrorType.Failed, "You must provide either `confirmHandler` or `confirmationTokenConfirmHandler`, but not both"))
+      emitLoadingFailed(message: "You must provide either `confirmHandler` or `confirmationTokenConfirmHandler`, but not both")
+      resolve(nil)
       return
     }
     let captureMethodString = intentConfig["captureMethod"] as? String
@@ -44,7 +47,8 @@ extension StripeSdkImpl {
     )
 
     guard let configuration = buildEmbeddedPaymentElementConfiguration(params: configuration).configuration else {
-      resolve(Errors.createError(ErrorType.Failed, "Invalid configuration"))
+      emitLoadingFailed(message: "Invalid configuration")
+      resolve(nil)
       return
     }
 
@@ -54,26 +58,88 @@ extension StripeSdkImpl {
           intentConfiguration: intentConfig,
           configuration: configuration
         )
-        embeddedPaymentElement.delegate = embeddedInstanceDelegate
-        embeddedPaymentElement.presentingViewController = RCTPresentedViewController()
-        self.embeddedInstance = embeddedPaymentElement
-
-        // success: resolve promise
+        attachEmbedded(embeddedPaymentElement)
         resolve(nil)
-
-        // publish initial state
-        embeddedInstanceDelegate.embeddedPaymentElementDidUpdateHeight(embeddedPaymentElement: embeddedPaymentElement)
-        embeddedInstanceDelegate.embeddedPaymentElementDidUpdatePaymentOption(embeddedPaymentElement: embeddedPaymentElement)
       } catch {
-        // 1) still resolve the promise so JS hook can finish loading
+        emitLoadingFailed(error: error)
+        // Resolve so the JS hook can finish loading; loading errors are
+        // surfaced through the embeddedPaymentElementLoadingFailed event.
         resolve(nil)
+      }
+    }
+  }
+
+  @objc(createEmbeddedPaymentElementWithCheckout:configuration:resolve:reject:)
+  public func createEmbeddedPaymentElementWithCheckout(
+    sessionKey: String,
+    configuration: NSDictionary,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let checkout = checkoutInstances[sessionKey] else {
+      emitLoadingFailed(message: "Checkout session not found")
+      resolve(nil)
+      return
+    }
+
+    guard let configuration = buildEmbeddedPaymentElementConfiguration(params: configuration).configuration else {
+      emitLoadingFailed(message: "Invalid configuration")
+      resolve(nil)
+      return
+    }
 
-        // 2) emit a loading‐failed event with the error message
-        let msg = error.localizedDescription
-        self.emitter?.emitEmbeddedPaymentElementLoadingFailed(["message": msg])
+    Task {
+      do {
+        let embeddedPaymentElement = try await EmbeddedPaymentElement.create(
+          checkout: checkout,
+          configuration: configuration
+        )
+        attachEmbedded(embeddedPaymentElement)
+        resolve(nil)
+      } catch {
+        emitLoadingFailed(error: error)
+        resolve(nil)
       }
     }
+  }
+
+  /// Wires up a freshly created element and emits its initial height /
+  /// payment-option state to JS.
+  @nonobjc
+  private func attachEmbedded(_ element: EmbeddedPaymentElement) {
+    element.delegate = embeddedInstanceDelegate
+    element.presentingViewController = RCTPresentedViewController()
+    self.embeddedInstance = element
 
+    embeddedInstanceDelegate.embeddedPaymentElementDidUpdateHeight(embeddedPaymentElement: element)
+    embeddedInstanceDelegate.embeddedPaymentElementDidUpdatePaymentOption(embeddedPaymentElement: element)
+  }
+
+  @nonobjc
+  private func emitLoadingFailed(message: String) {
+    self.emitter?.emitEmbeddedPaymentElementLoadingFailed(["message": message])
+  }
+
+  @nonobjc
+  private func emitLoadingFailed(error: Error) {
+    emitLoadingFailed(message: error.localizedDescription)
+  }
+
+  @nonobjc
+  private func resolveEmbeddedUpdateResult(
+    _ updateResult: EmbeddedPaymentElement.UpdateResult,
+    resolve: @escaping RCTPromiseResolveBlock
+  ) {
+    switch updateResult {
+    case .succeeded:
+      resolve(["status": "succeeded"])
+    case .canceled:
+      resolve(["status": "canceled"])
+    case .failed(let error):
+      self.emitter?.emitEmbeddedPaymentElementLoadingFailed(["message": error.localizedDescription])
+      // We don't resolve with an error b/c loading errors are handled via the embeddedPaymentElementLoadingFailed event
+      resolve(nil)
+    }
   }
 
   @objc(confirmEmbeddedPaymentElement:reject:)
@@ -143,16 +209,31 @@ extension StripeSdkImpl {
         return
       }
 
-      switch updateResult {
-      case .succeeded:
-        resolve(["status": "succeeded"])
-      case .canceled:
-        resolve(["status": "canceled"])
-      case .failed(let error):
-        self.emitter?.emitEmbeddedPaymentElementLoadingFailed(["message": error.localizedDescription])
-        // We don't resolve with an error b/c loading errors are handled via the embeddedPaymentElementLoadingFailed event
-        resolve(nil)
+      self.resolveEmbeddedUpdateResult(updateResult, resolve: resolve)
+    }
+  }
+
+  @objc(updateEmbeddedPaymentElementWithCheckout:resolve:reject:)
+  public func updateEmbeddedPaymentElementWithCheckout(
+    sessionKey: String,
+    resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let checkout = checkoutInstances[sessionKey] else {
+      resolve(Errors.createError(ErrorType.Failed, "Checkout session not found"))
+      return
+    }
+
+    Task {
+      guard let updateResult = await self.embeddedInstance?.update(checkout: checkout) else {
+        resolve(Errors.createError(
+          ErrorType.Failed,
+          "No EmbeddedPaymentElement instance — did you call create first?"
+        ))
+        return
       }
+
+      self.resolveEmbeddedUpdateResult(updateResult, resolve: resolve)
     }
   }
 

package/ios/StripeSdkImpl+PaymentSheet.swift

@@ -6,7 +6,7 @@
 //
 
 import Foundation
-@_spi(ExperimentalAllowsRemovalOfLastSavedPaymentMethodAPI) @_spi(CustomerSessionBetaAccess) @_spi(EmbeddedPaymentElementPrivateBeta) @_spi(STP) @_spi(PaymentMethodOptionsSetupFutureUsagePreview) @_spi(CustomPaymentMethodsBeta) @_spi(ConfirmationTokensPublicPreview) @_spi(CardFundingFilteringPrivatePreview) import StripePaymentSheet
+@_spi(ExperimentalAllowsRemovalOfLastSavedPaymentMethodAPI) @_spi(STP) @_spi(PaymentMethodOptionsSetupFutureUsagePreview) @_spi(CustomPaymentMethodsBeta) @_spi(ConfirmationTokensPublicPreview) @_spi(CardFundingFilteringPrivatePreview) import StripePaymentSheet
 
 extension StripeSdkImpl {
     internal func buildPaymentSheetConfiguration(
@@ -183,7 +183,23 @@ extension StripeSdkImpl {
             }
         }
 
-        if let paymentIntentClientSecret = params["paymentIntentClientSecret"] as? String {
+        if let checkout = params["checkout"] as? NSDictionary,
+          let sessionKey = checkout["sessionKey"] as? String {
+            guard let checkout = checkoutInstances[sessionKey] else {
+                resolve(Errors.createError(ErrorType.Failed, "Checkout session not found"))
+                return
+            }
+
+            if params["customFlow"] as? Bool == true {
+                PaymentSheet.FlowController.create(checkout: checkout,
+                                                   configuration: configuration) { [weak self] result in
+                    handlePaymentSheetFlowControllerResult(result: result, stripeSdk: self)
+                }
+            } else {
+                self.paymentSheet = PaymentSheet(checkout: checkout, configuration: configuration)
+                resolve([])
+            }
+        } else if let paymentIntentClientSecret = params["paymentIntentClientSecret"] as? String {
             if !Errors.isPIClientSecretValid(clientSecret: paymentIntentClientSecret) {
                 resolve(Errors.createError(ErrorType.Failed, "`secret` format does not match expected client secret formatting."))
                 return