@onramper/onramper-react-native 1.0.1

package/ios/HybridOnramperCheckoutButton.swift

@@ -0,0 +1,112 @@
+#if canImport(UIKit)
+import NitroModules
+import SwiftUI
+import UIKit
+
+/// Nitro view that renders the SwiftUI `OnramperCheckoutButton` produced by
+/// `getCheckoutRequirements` and stashed in `PreparedIntentRegistry.shared`
+/// under `intentHandle`. The button is hosted in a `UIHostingController` whose
+/// view is added to our container; the controller is attached as a child of the
+/// nearest React view controller so the SDK button can present its login /
+/// webview sheets.
+final class HybridOnramperCheckoutButton: HybridOnramperCheckoutButtonSpec {
+  private let container = CheckoutContainerView()
+  private var mountedHandle: String?
+
+  var intentHandle: String = "" {
+    didSet {
+      guard !intentHandle.isEmpty, intentHandle != mountedHandle else { return }
+      mount(handle: intentHandle)
+    }
+  }
+
+  var view: UIView { container }
+
+  private func mount(handle: String) {
+    mountedHandle = handle
+    Task { @MainActor [weak self] in
+      guard let self else { return }
+      guard let entry = await PreparedIntentRegistry.shared.consume(handle) else {
+        // Handle was invalidated or already consumed — leave the view empty.
+        return
+      }
+      // Pin the SwiftUI content to the container's width so long ToS text wraps
+      // instead of laying out at its intrinsic (single-line) width and spilling
+      // past the right edge. `.fixedSize(vertical:)` lets it grow downward.
+      self.container.host(AnyView(
+        entry.button
+          .frame(maxWidth: .infinity, alignment: .leading)
+          .fixedSize(horizontal: false, vertical: true)
+      ))
+    }
+  }
+}
+
+/// Container that hosts the SwiftUI button and (re)attaches the hosting
+/// controller to the React view-controller hierarchy when it enters a window.
+final class CheckoutContainerView: UIView {
+  private var hostingController: UIHostingController<AnyView>?
+
+  @MainActor
+  func host(_ rootView: AnyView) {
+    // Re-hosting (e.g. when `intentHandle` changes) must tear the previous
+    // controller down first, otherwise its view/constraints accumulate and the
+    // old controller stays childed to the parent VC.
+    detachHosted()
+    let controller = UIHostingController(rootView: rootView)
+    controller.view.backgroundColor = .clear
+    controller.view.translatesAutoresizingMaskIntoConstraints = false
+    hostingController = controller
+    addSubview(controller.view)
+    NSLayoutConstraint.activate([
+      controller.view.leadingAnchor.constraint(equalTo: leadingAnchor),
+      controller.view.trailingAnchor.constraint(equalTo: trailingAnchor),
+      controller.view.topAnchor.constraint(equalTo: topAnchor),
+      controller.view.bottomAnchor.constraint(equalTo: bottomAnchor),
+    ])
+    attachChildIfPossible()
+  }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    attachChildIfPossible()
+  }
+
+  private func attachChildIfPossible() {
+    guard let controller = hostingController, controller.parent == nil,
+          let parent = nearestViewController() else { return }
+    parent.addChild(controller)
+    controller.didMove(toParent: parent)
+  }
+
+  private func nearestViewController() -> UIViewController? {
+    var responder: UIResponder? = self
+    while let current = responder {
+      if let vc = current as? UIViewController { return vc }
+      responder = current.next
+    }
+    return nil
+  }
+
+  /// Detaches the currently hosted controller from the VC hierarchy and removes
+  /// its view/constraints. Safe to call when nothing is hosted.
+  @MainActor
+  private func detachHosted() {
+    guard let controller = hostingController else { return }
+    controller.willMove(toParent: nil)
+    controller.view.removeFromSuperview()
+    controller.removeFromParent()
+    hostingController = nil
+  }
+
+  deinit {
+    // deinit can't hop to @MainActor; the container is torn down on the main
+    // thread by UIKit, so touching the controller here is safe.
+    if let controller = hostingController {
+      controller.willMove(toParent: nil)
+      controller.view.removeFromSuperview()
+      controller.removeFromParent()
+    }
+  }
+}
+#endif

package/ios/HybridOnramperNitro.swift

@@ -0,0 +1,194 @@
+import Combine
+import Foundation
+import NitroModules
+import OnramperSDK
+import SwiftUI
+
+/// Nitro bridge to OnramperSDK's `OnramperClient`. Wraps the @MainActor SDK
+/// client, mirrors its `@Published state` and `events` stream to stored JS
+/// callbacks, and feeds the SDK's `sessionExpirationHandler` from a stored
+/// async JS callback. The public typed JS API lives in `OnramperClient.ts`.
+final class HybridOnramperNitro: HybridOnramperNitroSpec {
+  private var client: OnramperClient?
+  private var stateObservation: AnyCancellable?
+  private var eventTask: Task<Void, Never>?
+
+  private var onState: ((String) -> Void)?
+  private var onEvent: ((String) -> Void)?
+  // Nitro wraps a callback's return value in a Promise; our callback already
+  // returns Promise<NitroSessionCredentials>, hence the doubly-nested Promise.
+  private var sessionHandler: (() -> Promise<Promise<NitroSessionCredentials>>)?
+
+  // Handle of the most recent prepared intent owned by *this* client, used to
+  // enforce single-flight per client without touching other clients' intents.
+  private var lastPreparedHandle: String?
+
+  // MARK: - Listener registration (synchronous)
+
+  func setStateListener(onState: @escaping (String) -> Void) {
+    self.onState = onState
+  }
+
+  func setEventListener(onEvent: @escaping (String) -> Void) {
+    self.onEvent = onEvent
+  }
+
+  func setSessionExpirationHandler(handler: @escaping () -> Promise<Promise<NitroSessionCredentials>>) {
+    self.sessionHandler = handler
+  }
+
+  // MARK: - Lifecycle
+
+  func configure(config: OnramperNitroConfig) throws -> Promise<Void> {
+    return Promise.async { [weak self] in
+      guard let self else { return }
+      try await self.performConfigure(config)
+    }
+  }
+
+  @MainActor
+  private func performConfigure(_ config: OnramperNitroConfig) async throws {
+    // Idempotent: a second configure() with the SDK already built is a no-op.
+    if client != nil { return }
+
+    let environment: OnramperConfiguration.Environment =
+      config.environment == "development" ? .development : .production
+    let theme: OnramperConfiguration.Theme = {
+      switch config.theme {
+      case "light": return .light
+      case "dark": return .dark
+      default: return .system
+      }
+    }()
+    let logLevel: LogLevel = {
+      switch config.logLevel {
+      case "error": return .error
+      case "info": return .info
+      case "debug": return .debug
+      default: return .off
+      }
+    }()
+
+    let swiftConfig = OnramperConfiguration(
+      apiKey: config.apiKey,
+      clientId: config.clientId,
+      environment: environment,
+      theme: theme,
+      logLevel: logLevel,
+      sessionExpirationHandler: { [weak self] in
+        guard let self, let handler = self.sessionHandler else {
+          throw OnramperError.userTokenRefreshFailed("no session expiration handler registered")
+        }
+        // Await twice: outer Promise = the callback invocation, inner Promise =
+        // the JS async function's own returned Promise. Then map to the SDK type.
+        let creds = try await handler().await().await()
+        return SessionCredentials(sessionId: creds.sessionId, sessionToken: creds.sessionToken)
+      }
+    )
+
+    let newClient = OnramperClient(configuration: swiftConfig)
+    client = newClient
+    attachObservers(to: newClient)
+  }
+
+  @MainActor
+  private func attachObservers(to client: OnramperClient) {
+    stateObservation = client.$state.sink { [weak self] state in
+      self?.onState?(jsonString(state.toJSDict()))
+    }
+    // `events` is a computed AsyncStream that captures a single continuation, so
+    // access it exactly once here. CheckoutEvent is Sendable → safe to iterate
+    // off the main actor.
+    let stream = client.events
+    eventTask = Task { [weak self] in
+      for await event in stream {
+        self?.onEvent?(jsonString(event.toJSDict()))
+      }
+    }
+  }
+
+  @MainActor
+  private func requireClient() throws -> OnramperClient {
+    guard let client else { throw OnramperError.notInitialized }
+    return client
+  }
+
+  func initialize(sessionId: String, sessionToken: String) throws -> Promise<Void> {
+    return Promise.async { [weak self] in
+      guard let self else { return }
+      let client = try await self.requireClient()
+      try await client.initialize(sessionId: sessionId, sessionToken: sessionToken)
+    }
+  }
+
+  func reset() throws -> Promise<Void> {
+    return Promise.async { [weak self] in
+      guard let self else { return }
+      let client = try await self.requireClient()
+      await client.reset()
+    }
+  }
+
+  func signOut() throws -> Promise<Void> {
+    return Promise.async { [weak self] in
+      guard let self else { return }
+      let client = try await self.requireClient()
+      await client.signOut()
+    }
+  }
+
+  // MARK: - Checkout
+
+  func getCheckoutRequirements(requestJson: String, styleJson: String) throws -> Promise<PreparedIntentResult> {
+    return Promise.async { [weak self] in
+      guard let self else { throw OnramperError.notInitialized }
+      return try await self.performGetCheckoutRequirements(requestJson: requestJson, styleJson: styleJson)
+    }
+  }
+
+  @MainActor
+  private func performGetCheckoutRequirements(requestJson: String, styleJson: String) async throws -> PreparedIntentResult {
+    let client = try requireClient()
+    let request = try decodeCheckoutRequest(requestJson)
+    let style = decodeCheckoutButtonStyle(styleJson)
+
+    // Single-flight, scoped to this client: a new prepared intent supersedes
+    // this instance's prior unconsumed one, but leaves other clients' intents
+    // in the shared registry untouched.
+    if let prev = lastPreparedHandle {
+      await PreparedIntentRegistry.shared.drop(prev)
+    }
+
+    let result = try await client.getCheckoutRequirements(request, buttonStyle: style)
+    let entry = PreparedIntentRegistry.PreparedIntent(button: AnyView(result.button), createdAt: Date())
+    let handle = await PreparedIntentRegistry.shared.store(entry)
+    lastPreparedHandle = handle
+    let quoteDict = (codableToJSValue(result.quote) as? [String: Any]) ?? [:]
+    return PreparedIntentResult(intentHandle: handle, quoteJson: jsonString(quoteDict))
+  }
+
+  func cancelPreparedIntent(intentHandle: String) throws -> Promise<Void> {
+    if intentHandle == lastPreparedHandle {
+      lastPreparedHandle = nil
+    }
+    return Promise.async {
+      await PreparedIntentRegistry.shared.drop(intentHandle)
+    }
+  }
+
+  // MARK: - Teardown
+
+  /// Releases the stored JS callbacks (Nitro holds strong refs to them) and the
+  /// SDK client. Called from `OnramperClient.destroy()` in JS.
+  func dispose() {
+    stateObservation?.cancel()
+    stateObservation = nil
+    eventTask?.cancel()
+    eventTask = nil
+    onState = nil
+    onEvent = nil
+    sessionHandler = nil
+    lastPreparedHandle = nil
+    client = nil
+  }
+}

package/ios/OnramperCheckoutBridge.swift

@@ -0,0 +1,88 @@
+#if canImport(UIKit)
+import Foundation
+import OnramperSDK
+import SwiftUI
+
+// Decodes the flat JS CheckoutRequest / CheckoutButtonStyle JSON into the SDK's
+// nested request + styled button config. (The SDK's OnramperTransactionData.init
+// lowercases ISO codes, so we construct via inits rather than Codable-decoding
+// straight into CheckoutIntentRequest.)
+
+private struct CheckoutRequestJSON: Decodable {
+  let source: String
+  let destination: String?
+  let amount: Double
+  let type: String
+  let country: String?
+  let subdivision: String?
+  let paymentMethod: String
+  let wallet: WalletJSON
+  let onlyOnramps: [String]?
+
+  struct WalletJSON: Decodable {
+    let network: String
+    let address: String
+    let memo: String?
+  }
+}
+
+func decodeCheckoutRequest(_ json: String) throws -> CheckoutIntentRequest {
+  guard let data = json.data(using: .utf8) else {
+    throw OnramperError.invalidRequest(field: nil, debugInfo: "request JSON not UTF-8")
+  }
+  do {
+    let r = try JSONDecoder().decode(CheckoutRequestJSON.self, from: data)
+    let txData = OnramperTransactionData(
+      source: r.source,
+      destination: r.destination,
+      amount: r.amount,
+      type: r.type == "sell" ? .sell : .buy,
+      country: r.country,
+      subdivision: r.subdivision,
+      paymentMethod: r.paymentMethod,
+      wallet: WalletInfo(network: r.wallet.network, address: r.wallet.address, memo: r.wallet.memo)
+    )
+    return CheckoutIntentRequest(onramperTransactionData: txData, onlyOnramps: r.onlyOnramps)
+  } catch {
+    throw OnramperError.invalidRequest(field: nil, debugInfo: "request decode failed: \(error)")
+  }
+}
+
+private struct CheckoutButtonStyleJSON: Decodable {
+  let backgroundColor: String?
+  let foregroundColor: String?
+  let borderRadius: Double?
+}
+
+func decodeCheckoutButtonStyle(_ json: String) -> CheckoutButtonStyle {
+  var style = CheckoutButtonStyle()
+  guard let data = json.data(using: .utf8),
+        let s = try? JSONDecoder().decode(CheckoutButtonStyleJSON.self, from: data) else {
+    return style
+  }
+  if let hex = s.backgroundColor, let color = Color(hex: hex) { style.backgroundColor = color }
+  if let hex = s.foregroundColor, let color = Color(hex: hex) { style.foregroundColor = color }
+  if let radius = s.borderRadius { style.borderRadius = CGFloat(radius) }
+  return style
+}
+
+extension Color {
+  init?(hex: String) {
+    let s = hex.trimmingCharacters(in: CharacterSet(charactersIn: "#"))
+    guard s.count == 6 || s.count == 8, let value = UInt64(s, radix: 16) else { return nil }
+    let r, g, b, a: Double
+    if s.count == 6 {
+      r = Double((value >> 16) & 0xFF) / 255
+      g = Double((value >> 8) & 0xFF) / 255
+      b = Double(value & 0xFF) / 255
+      a = 1
+    } else {
+      r = Double((value >> 24) & 0xFF) / 255
+      g = Double((value >> 16) & 0xFF) / 255
+      b = Double((value >> 8) & 0xFF) / 255
+      a = Double(value & 0xFF) / 255
+    }
+    self = Color(.sRGB, red: r, green: g, blue: b, opacity: a)
+  }
+}
+#endif

package/ios/OnramperSDKBridge.swift

@@ -0,0 +1,185 @@
+import Foundation
+import OnramperSDK
+
+// Maps the SDK's non-Codable Swift enums (OnramperState, CheckoutEvent) and
+// OnramperError into JS-friendly dictionaries, then to JSON strings for the
+// Nitro bridge. This is SDK-shape mapping, not Expo-specific — it has no
+// dependency on any bridging framework.
+
+// MARK: - Error → code / structured info
+
+extension OnramperError {
+  var jsCode: String {
+    switch self {
+    case .notInitialized: return "notInitialized"
+    case .initializationFailed: return "initializationFailed"
+    case .attestationFailed: return "attestationFailed"
+    case .invalidStateTransition: return "invalidStateTransition"
+    case .invalidState: return "invalidState"
+    case .networkError: return "networkError"
+    case .decodingError: return "decodingError"
+    case .timeout: return "timeout"
+    case .requirementNotSatisfied: return "requirementNotSatisfied"
+    case .amountOutOfRange: return "amountOutOfRange"
+    case .oidcFlowCancelled: return "oidcFlowCancelled"
+    case .oidcTokenExchangeFailed: return "oidcTokenExchangeFailed"
+    case .oidcFlowFailed: return "oidcFlowFailed"
+    case .userTokenInvalid: return "userTokenInvalid"
+    case .userTokenRefreshFailed: return "userTokenRefreshFailed"
+    case .webviewLoadFailed: return "webviewLoadFailed"
+    case .deepLinkFailed: return "deepLinkFailed"
+    case .invalidRequest: return "invalidRequest"
+    case .quoteUnavailable: return "quoteUnavailable"
+    case .checkoutForbidden: return "checkoutForbidden"
+    case .temporaryFailure: return "temporaryFailure"
+    case .unrecoverable: return "unrecoverable"
+    case .configurationError: return "configurationError"
+    case .deviceBlocked: return "deviceBlocked"
+    case .securityStorageFailed: return "securityStorageFailed"
+    case .securityTrustFailed: return "securityTrustFailed"
+    }
+  }
+
+  var jsInfo: [String: Any]? {
+    switch self {
+    case .amountOutOfRange(let min, let max):
+      return ["min": min, "max": max]
+    case .networkError(let code, _):
+      return ["status": code]
+    case .securityStorageFailed(let status):
+      return ["status": Int(status)]
+    case .securityTrustFailed(let host):
+      return ["host": host]
+    case .invalidStateTransition(let from, let to):
+      return ["from": from, "to": to]
+    case .invalidState(let expected, let actual):
+      return ["expected": expected, "actual": actual]
+    case .invalidRequest(let field, let debugInfo):
+      var info: [String: Any] = [:]
+      if let field { info["field"] = field }
+      if let debugInfo { info["debugInfo"] = debugInfo }
+      return info.isEmpty ? nil : info
+    case .temporaryFailure(let retryAfter, let debugInfo):
+      var info: [String: Any] = [:]
+      if let retryAfter { info["retryAfter"] = retryAfter }
+      if let debugInfo { info["debugInfo"] = debugInfo }
+      return info.isEmpty ? nil : info
+    case .quoteUnavailable(let debugInfo),
+         .checkoutForbidden(let debugInfo),
+         .unrecoverable(let debugInfo):
+      return debugInfo.map { ["debugInfo": $0] }
+    default:
+      return nil
+    }
+  }
+
+  /// A JS-friendly error dict: `{ code, message, info? }`.
+  func toJSDict() -> [String: Any] {
+    var dict: [String: Any] = ["code": jsCode, "message": errorDescription ?? "Unknown error"]
+    if let info = jsInfo { dict["info"] = info }
+    return dict
+  }
+}
+
+// MARK: - Enum raw values
+
+extension RenderType {
+  var jsValue: String { rawValue } // "webview" | "deeplink"
+}
+
+extension CheckoutPaymentType {
+  var jsValue: String { rawValue } // "applepay" | "revolutpay"
+}
+
+// MARK: - State → dict
+
+extension OnramperState {
+  func toJSDict() -> [String: Any] {
+    switch self {
+    case .idle: return ["kind": "idle"]
+    case .initializing: return ["kind": "initializing"]
+    case .ready: return ["kind": "ready"]
+    case .checkoutPreparing: return ["kind": "checkoutPreparing"]
+    case .requireLogin(let requirements):
+      return ["kind": "requireLogin", "requirements": codableToJSArray(requirements)]
+    case .authenticating: return ["kind": "authenticating"]
+    case .readyToCheckout: return ["kind": "readyToCheckout"]
+    case .finalizing: return ["kind": "finalizing"]
+    case .rendering(let ctx):
+      return [
+        "kind": "rendering",
+        "url": ctx.url.absoluteString,
+        "renderType": ctx.renderType.jsValue,
+        "paymentType": ctx.paymentType.jsValue,
+      ]
+    case .completed: return ["kind": "completed"]
+    case .failed(let error):
+      return ["kind": "failed", "error": error.toJSDict()]
+    }
+  }
+}
+
+// MARK: - Event → dict
+
+extension CheckoutEvent {
+  func toJSDict() -> [String: Any] {
+    switch self {
+    case .stateChanged(let state):
+      return ["type": "stateChanged", "state": state.toJSDict()]
+    case .checkoutStarted(let intentId):
+      return ["type": "checkoutStarted", "intentId": intentId]
+    case .loginRequired(let requirements):
+      return ["type": "loginRequired", "requirements": codableToJSArray(requirements)]
+    case .readyToCheckout:
+      return ["type": "readyToCheckout"]
+    case .requirementSatisfied(let kind):
+      return ["type": "requirementSatisfied", "requirementType": kind.rawValue]
+    case .checkoutFinalized(let response):
+      return ["type": "checkoutFinalized", "response": codableToJSValue(response)]
+    case .renderingStarted(let url, let renderType):
+      return ["type": "renderingStarted", "url": url.absoluteString, "renderType": renderType.jsValue]
+    case .completed(let checkoutId):
+      return ["type": "completed", "checkoutId": checkoutId]
+    case .failed(let err):
+      return ["type": "failed", "error": err.toJSDict()]
+    case .checkoutCancelled:
+      return ["type": "cancelled"]
+    // Provider-lifecycle events (third-party checkout webviews).
+    case .providerReady:
+      return ["type": "providerReady"]
+    case .paymentAuthorized:
+      return ["type": "paymentAuthorized"]
+    case .paymentProcessing:
+      return ["type": "paymentProcessing"]
+    case .paymentCancelled:
+      return ["type": "paymentCancelled"]
+    case .providerError(let reason):
+      return ["type": "providerError", "reason": reason]
+    }
+  }
+}
+
+// MARK: - Codable → JS value / JSON string
+
+func codableToJSValue<T: Codable>(_ value: T) -> Any {
+  guard let data = try? JSONEncoder().encode(value),
+        let obj = try? JSONSerialization.jsonObject(with: data) else {
+    return [:]
+  }
+  return obj
+}
+
+func codableToJSArray<T: Codable>(_ values: [T]) -> [Any] {
+  (codableToJSValue(values) as? [Any]) ?? []
+}
+
+/// Serializes a JS-friendly dict to a JSON string for transport across the
+/// Nitro callback boundary. Returns "{}" on failure (should not happen for the
+/// fixed-shape dicts produced above).
+func jsonString(_ dict: [String: Any]) -> String {
+  guard let data = try? JSONSerialization.data(withJSONObject: dict),
+        let str = String(data: data, encoding: .utf8) else {
+    return "{}"
+  }
+  return str
+}

package/ios/PreparedIntentRegistry.swift

@@ -0,0 +1,78 @@
+import Foundation
+import Security
+import SwiftUI
+
+actor PreparedIntentRegistry {
+    /// Process-wide registry. `getCheckoutRequirements` (on HybridOnramperNitro)
+    /// stores the SwiftUI button under a ULID handle; the separate
+    /// HybridOnramperCheckoutButton view consumes it by handle. Handles are
+    /// unique ULIDs, so a single shared registry is safe across clients.
+    static let shared = PreparedIntentRegistry()
+
+    struct PreparedIntent {
+        let button: AnyView
+        let createdAt: Date
+        var consumed: Bool = false
+    }
+
+    private var entries: [String: PreparedIntent] = [:]
+    private let ttl: TimeInterval
+
+    init(ttl: TimeInterval = 300) {
+        self.ttl = ttl
+    }
+
+    func store(_ entry: PreparedIntent) -> String {
+        sweepExpired()
+        let handle = Self.makeULID()
+        entries[handle] = entry
+        return handle
+    }
+
+    func consume(_ handle: String) -> PreparedIntent? {
+        guard var entry = entries[handle], !entry.consumed else { return nil }
+        entry.consumed = true
+        entries[handle] = entry
+        return entry
+    }
+
+    func drop(_ handle: String) {
+        entries.removeValue(forKey: handle)
+    }
+
+    func invalidateAll() {
+        entries.removeAll()
+    }
+
+    private func sweepExpired() {
+        let now = Date()
+        entries = entries.filter { now.timeIntervalSince($0.value.createdAt) < ttl }
+    }
+
+    private static func makeULID() -> String {
+        var bytes = [UInt8](repeating: 0, count: 16)
+        _ = SecRandomCopyBytes(kSecRandomDefault, 10, &bytes[6])
+        let ts = UInt64(Date().timeIntervalSince1970 * 1000)
+        for i in 0..<6 {
+            bytes[i] = UInt8((ts >> ((5 - i) * 8)) & 0xFF)
+        }
+        let alphabet = Array("0123456789ABCDEFGHJKMNPQRSTVWXYZ")
+        var out = ""
+        var bits: UInt64 = 0
+        var bitCount = 0
+        for byte in bytes {
+            bits = (bits << 8) | UInt64(byte)
+            bitCount += 8
+            while bitCount >= 5 {
+                bitCount -= 5
+                let idx = Int((bits >> bitCount) & 0x1F)
+                out.append(alphabet[idx])
+            }
+        }
+        if bitCount > 0 {
+            let idx = Int((bits << (5 - bitCount)) & 0x1F)
+            out.append(alphabet[idx])
+        }
+        return String(out.prefix(26))
+    }
+}

package/lib/commonjs/OnramperCheckoutButtonView.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnramperCheckoutButtonView = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _OnramperCheckoutButtonConfig = _interopRequireDefault(require("./generated/OnramperCheckoutButtonConfig.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Native checkout button. Renders the SwiftUI `OnramperCheckoutButton` that
+ * `OnramperClient.getCheckoutRequirements()` prepared, addressed by `intentHandle`.
+ * Standard view props (e.g. `style`) are supported via `HybridViewProps`.
+ */
+const OnramperCheckoutButtonView = exports.OnramperCheckoutButtonView = (0, _reactNativeNitroModules.getHostComponent)('OnramperCheckoutButton', () => _OnramperCheckoutButtonConfig.default);
+//# sourceMappingURL=OnramperCheckoutButtonView.js.map

package/lib/commonjs/OnramperCheckoutButtonView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_OnramperCheckoutButtonConfig","_interopRequireDefault","e","__esModule","default","OnramperCheckoutButtonView","exports","getHostComponent","OnramperCheckoutButtonConfig"],"sourceRoot":"../../src","sources":["OnramperCheckoutButtonView.tsx"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AACA,IAAAC,6BAAA,GAAAC,sBAAA,CAAAF,OAAA;AAAyF,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAKzF;AACA;AACA;AACA;AACA;AACO,MAAMG,0BAA0B,GAAAC,OAAA,CAAAD,0BAAA,GAAG,IAAAE,yCAAgB,EACxD,wBAAwB,EACxB,MAAMC,qCACR,CAAC","ignoreList":[]}