framepayments-react-native 3.0.1 → 4.0.0

package/android/src/main/java/com/framepayments/reactnativeframe/FrameGooglePayActivity.kt

@@ -1,168 +0,0 @@
-package com.framepayments.reactnativeframe
-
-import android.content.Intent
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
-import android.widget.FrameLayout
-import androidx.appcompat.app.AppCompatActivity
-import com.framepayments.framesdk_ui.buttons.FrameGooglePayButton
-
-/**
- * Hidden host activity for Frame.presentGooglePay(). The Frame Android SDK only
- * exposes Google Pay through FrameGooglePayButton (a View). This activity
- * instantiates that View off-screen, waits for readiness, then programmatically
- * clicks the inner Google Pay button so the wallet sheet appears. The result
- * is forwarded back via setResult / FrameSDKModule.onActivityResult.
- *
- * The Activity finishes after the result arrives or after a 5s readiness timeout.
- */
-class FrameGooglePayActivity : AppCompatActivity() {
-
-  private val handler = Handler(Looper.getMainLooper())
-  private var googlePayButton: FrameGooglePayButton? = null
-  private var didTriggerClick = false
-  private var didDeliverResult = false
-  private var readinessTimeout: Runnable? = null
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-
-    val container = FrameLayout(this).apply {
-      layoutParams = FrameLayout.LayoutParams(
-        FrameLayout.LayoutParams.MATCH_PARENT,
-        FrameLayout.LayoutParams.MATCH_PARENT
-      )
-    }
-    setContentView(container)
-
-    val amountCents = intent.getIntExtra(EXTRA_AMOUNT_CENTS, 0)
-    val ownerType = intent.getStringExtra(EXTRA_OWNER_TYPE)
-    val ownerId = intent.getStringExtra(EXTRA_OWNER_ID)
-    val currencyCode = intent.getStringExtra(EXTRA_CURRENCY) ?: "USD"
-
-    if (amountCents <= 0) {
-      deliverFailure("Invalid amountCents")
-      return
-    }
-    if (ownerId.isNullOrEmpty()) {
-      deliverFailure("owner.id is required")
-      return
-    }
-    val owner: FrameGooglePayButton.Owner = when (ownerType) {
-      "customer" -> FrameGooglePayButton.Owner.Customer(ownerId)
-      "account"  -> FrameGooglePayButton.Owner.Account(ownerId)
-      else -> {
-        deliverFailure("owner.type must be 'customer' or 'account'")
-        return
-      }
-    }
-
-    val button = FrameGooglePayButton(this)
-    button.layoutParams = FrameLayout.LayoutParams(1, 1) // tiny but measurable so click can fire
-    container.addView(button)
-    googlePayButton = button
-
-    button.configure(
-      amountCents = amountCents,
-      owner = owner,
-      currencyCode = currencyCode,
-      onResult = { result -> handleResult(result) },
-      onReadinessChanged = { isReady -> handleReadiness(isReady) }
-    )
-
-    // Bail out if Google Pay isn't ready within 5s.
-    readinessTimeout = Runnable {
-      if (!didTriggerClick && !didDeliverResult) {
-        deliverUnavailable()
-      }
-    }
-    handler.postDelayed(readinessTimeout!!, 5000)
-  }
-
-  private fun handleReadiness(isReady: Boolean) {
-    if (didTriggerClick || didDeliverResult) return
-    if (!isReady) return
-    didTriggerClick = true
-    val button = googlePayButton ?: return
-    // The inner Google Pay button (child 0 of FrameGooglePayButton) carries the
-    // OnClickListener that calls requestGooglePay(). Click on the outer
-    // FrameLayout does not propagate.
-    val inner = if (button.childCount > 0) button.getChildAt(0) else null
-    handler.post {
-      if (inner != null) {
-        inner.performClick()
-      } else {
-        deliverFailure("Could not find inner Google Pay button")
-      }
-    }
-  }
-
-  private fun handleResult(result: FrameGooglePayButton.Result) {
-    if (didDeliverResult) return
-    didDeliverResult = true
-    when (result) {
-      is FrameGooglePayButton.Result.Success -> {
-        // `result.id` is a Transfer id (for Owner.Account) or a ChargeIntent id
-        // (for Owner.Customer). JS knows which it is because it passed the owner.
-        deliverViaCallback(android.app.Activity.RESULT_OK, Intent().putExtra(EXTRA_CHARGE_ID, result.id))
-      }
-      is FrameGooglePayButton.Result.PaymentMethodCreated -> {
-        // RN bridge does not currently expose AddToOwner mode, so this branch
-        // shouldn't fire in practice. Surface it as failure instead of silently dropping.
-        deliverViaCallback(RESULT_FAILURE, Intent().putExtra(EXTRA_FAILURE_MESSAGE, "Unsupported Google Pay result"))
-      }
-      is FrameGooglePayButton.Result.Failure -> {
-        deliverViaCallback(RESULT_FAILURE, Intent().putExtra(EXTRA_FAILURE_MESSAGE, result.message))
-      }
-      is FrameGooglePayButton.Result.Cancelled -> {
-        deliverViaCallback(android.app.Activity.RESULT_CANCELED, null)
-      }
-    }
-  }
-
-  private fun deliverUnavailable() {
-    if (didDeliverResult) return
-    didDeliverResult = true
-    deliverViaCallback(RESULT_UNAVAILABLE, null)
-  }
-
-  private fun deliverFailure(message: String) {
-    if (didDeliverResult) return
-    didDeliverResult = true
-    deliverViaCallback(RESULT_FAILURE, Intent().putExtra(EXTRA_FAILURE_MESSAGE, message))
-  }
-
-  private fun deliverViaCallback(resultCode: Int, data: Intent?) {
-    val callback = FrameSDKModule.pendingGooglePayCallback
-    FrameSDKModule.pendingGooglePayCallback = null
-    callback?.invoke(resultCode, data)
-    finish()
-  }
-
-  override fun onDestroy() {
-    readinessTimeout?.let { handler.removeCallbacks(it) }
-    readinessTimeout = null
-    super.onDestroy()
-  }
-
-  companion object {
-    const val EXTRA_AMOUNT_CENTS = "amount_cents"
-    const val EXTRA_OWNER_TYPE = "owner_type"
-    const val EXTRA_OWNER_ID = "owner_id"
-    const val EXTRA_CURRENCY = "currency"
-    /**
-     * The id of the resource created by the wallet flow. Holds a Transfer id when
-     * the owner was an account, or a ChargeIntent id when the owner was a customer.
-     * JS knows which by inspecting the owner it passed in.
-     */
-    const val EXTRA_CHARGE_ID = "charge_id"
-    const val EXTRA_FAILURE_MESSAGE = "failure_message"
-
-    const val REQUEST_CODE = 9003
-
-    // RESULT_FIRST_USER == 1; we use that to distinguish payment failure from cancel.
-    const val RESULT_FAILURE = android.app.Activity.RESULT_FIRST_USER
-    const val RESULT_UNAVAILABLE = android.app.Activity.RESULT_FIRST_USER + 1
-  }
-}

package/android/src/main/java/com/framepayments/reactnativeframe/FrameOnboardingActivity.kt

@@ -1,73 +0,0 @@
-package com.framepayments.reactnativeframe
-
-import android.content.Intent
-import android.os.Bundle
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import com.framepayments.frameonboarding.classes.Capabilities
-import com.framepayments.frameonboarding.classes.OnboardingConfig
-import com.framepayments.frameonboarding.classes.OnboardingResult
-import com.framepayments.frameonboarding.views.OnboardingContainerView
-import com.framepayments.framesdk_ui.theme.FrameTheme
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-
-class FrameOnboardingActivity : ComponentActivity() {
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    val accountId = intent.getStringExtra(EXTRA_ACCOUNT_ID)
-    val capabilitiesJson = intent.getStringExtra(EXTRA_CAPABILITIES_JSON) ?: "[]"
-    val capabilities = parseCapabilities(capabilitiesJson)
-
-    val config = OnboardingConfig(
-      accountId = accountId,
-      requiredCapabilities = capabilities
-    )
-
-    val themeOverride = FrameRNTheme.current
-    setContent {
-      val theme = themeOverride ?: FrameTheme.default(this)
-      FrameTheme(theme = theme) {
-        OnboardingContainerView(config = config) { result ->
-          when (result) {
-            is OnboardingResult.Completed -> {
-              val data = Intent().apply {
-                putExtra(EXTRA_PAYMENT_METHOD_ID, result.paymentMethodId)
-              }
-              setResult(RESULT_OK, data)
-              finish()
-            }
-            is OnboardingResult.Cancelled -> {
-              setResult(RESULT_CANCELED)
-              finish()
-            }
-            is OnboardingResult.Failed -> {
-              setResult(RESULT_CANCELED)
-              finish()
-            }
-          }
-        }
-      }
-    }
-  }
-
-  private fun parseCapabilities(json: String): List<Capabilities> {
-    return try {
-      val type = object : TypeToken<List<String>>() {}.type
-      val rawList: List<String> = Gson().fromJson(json, type)
-      rawList.mapNotNull { raw ->
-        Capabilities.entries.find { it.apiValue == raw }
-      }
-    } catch (e: Exception) {
-      emptyList()
-    }
-  }
-
-  companion object {
-    const val EXTRA_ACCOUNT_ID = "account_id"
-    const val EXTRA_CAPABILITIES_JSON = "capabilities_json"
-    const val EXTRA_PAYMENT_METHOD_ID = "payment_method_id"
-    const val REQUEST_CODE = 9003
-  }
-}

package/android/src/main/java/com/framepayments/reactnativeframe/FrameRNTheme.kt

@@ -1,138 +0,0 @@
-package com.framepayments.reactnativeframe
-
-import android.content.Context
-import android.graphics.Typeface
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.facebook.react.bridge.ReadableMap
-import com.framepayments.framesdk_ui.theme.FrameTheme
-
-object FrameRNTheme {
-
-  @Volatile
-  var current: FrameTheme? = null
-
-  fun parse(context: Context, dict: ReadableMap): FrameTheme {
-    val defaults = FrameTheme.Companion.default(context)
-    val colors = parseColors(dict.getMapOrNull("colors"), defaults)
-    val fonts = parseFonts(context, dict.getMapOrNull("fonts"), defaults)
-    val radii = parseRadii(dict.getMapOrNull("radii"), defaults)
-    return FrameTheme(colors = colors, fonts = fonts, radii = radii)
-  }
-
-  private fun parseColors(dict: ReadableMap?, defaults: FrameTheme) = defaults.colors.let { c ->
-    if (dict == null) return@let c
-    c.copy(
-      primaryButton = dict.color("primaryButton") ?: c.primaryButton,
-      primaryButtonText = dict.color("primaryButtonText") ?: c.primaryButtonText,
-      secondaryButton = dict.color("secondaryButton") ?: c.secondaryButton,
-      secondaryButtonText = dict.color("secondaryButtonText") ?: c.secondaryButtonText,
-      disabledButton = dict.color("disabledButton") ?: c.disabledButton,
-      disabledButtonStroke = dict.color("disabledButtonStroke") ?: c.disabledButtonStroke,
-      disabledButtonText = dict.color("disabledButtonText") ?: c.disabledButtonText,
-      surface = dict.color("surface") ?: c.surface,
-      surfaceStroke = dict.color("surfaceStroke") ?: c.surfaceStroke,
-      textPrimary = dict.color("textPrimary") ?: c.textPrimary,
-      textSecondary = dict.color("textSecondary") ?: c.textSecondary,
-      error = dict.color("error") ?: c.error,
-      onboardingHeaderBackground = dict.color("onboardingHeaderBackground") ?: c.onboardingHeaderBackground,
-      onboardingProgressFilledOnBrand = dict.color("onboardingProgressFilledOnBrand") ?: c.onboardingProgressFilledOnBrand,
-      onboardingProgressEmptyOnBrand = dict.color("onboardingProgressEmptyOnBrand") ?: c.onboardingProgressEmptyOnBrand
-    )
-  }
-
-  private fun parseFonts(context: Context, dict: ReadableMap?, defaults: FrameTheme) = defaults.fonts.let { f ->
-    if (dict == null) return@let f
-    f.copy(
-      title = dict.textStyle(context, "title", f.title),
-      heading = dict.textStyle(context, "heading", f.heading),
-      headline = dict.textStyle(context, "headline", f.headline),
-      body = dict.textStyle(context, "body", f.body),
-      bodySmall = dict.textStyle(context, "bodySmall", f.bodySmall),
-      label = dict.textStyle(context, "label", f.label),
-      caption = dict.textStyle(context, "caption", f.caption),
-      button = dict.textStyle(context, "button", f.button)
-    )
-  }
-
-  private fun parseRadii(dict: ReadableMap?, defaults: FrameTheme) = defaults.radii.let { r ->
-    if (dict == null) return@let r
-    r.copy(
-      small = dict.dp("small") ?: r.small,
-      medium = dict.dp("medium") ?: r.medium,
-      large = dict.dp("large") ?: r.large
-    )
-  }
-
-  private fun ReadableMap.getMapOrNull(key: String): ReadableMap? =
-    if (hasKey(key) && !isNull(key)) getMap(key) else null
-
-  private fun ReadableMap.color(key: String): Color? {
-    if (!hasKey(key) || isNull(key)) return null
-    val hex = getString(key) ?: return null
-    return parseHexColor(hex)
-  }
-
-  private fun ReadableMap.dp(key: String) =
-    if (hasKey(key) && !isNull(key)) getDouble(key).dp else null
-
-  private fun ReadableMap.textStyle(context: Context, key: String, default: TextStyle): TextStyle {
-    if (!hasKey(key) || isNull(key)) return default
-    val entry = getMap(key) ?: return default
-    val sizePt = if (entry.hasKey("size") && !entry.isNull("size")) entry.getDouble("size") else return default
-    val name = if (entry.hasKey("name") && !entry.isNull("name")) entry.getString("name") else null
-    val family = resolveFontFamily(context, name)
-    return default.copy(fontSize = sizePt.sp, fontFamily = family)
-  }
-
-  private val fontFamilyCache = mutableMapOf<String, FontFamily>()
-
-  private fun resolveFontFamily(context: Context, name: String?): FontFamily {
-    if (name.isNullOrBlank() || name.equals("system", ignoreCase = true)) return FontFamily.Default
-    fontFamilyCache[name]?.let { return it }
-    val typeface = loadAssetTypeface(context, name) ?: return FontFamily.Default
-    val family = FontFamily(typeface)
-    fontFamilyCache[name] = family
-    return family
-  }
-
-  private fun loadAssetTypeface(context: Context, name: String): Typeface? {
-    val assets = context.assets
-    val candidates = buildList {
-      add("fonts/$name")
-      add("fonts/$name.ttf")
-      add("fonts/$name.otf")
-    }
-    for (path in candidates) {
-      try {
-        return Typeface.createFromAsset(assets, path)
-      } catch (_: Exception) {
-      }
-    }
-    return null
-  }
-
-  private fun parseHexColor(input: String): Color? {
-    var s = input.trim()
-    if (s.startsWith("#")) s = s.substring(1)
-    if (s.length == 3) s = s.map { "$it$it" }.joinToString("")
-    if (s.length != 6 && s.length != 8) return null
-    val v = s.toLongOrNull(16) ?: return null
-    val r: Int; val g: Int; val b: Int; val a: Int
-    if (s.length == 6) {
-      r = ((v shr 16) and 0xff).toInt()
-      g = ((v shr 8) and 0xff).toInt()
-      b = (v and 0xff).toInt()
-      a = 255
-    } else {
-      r = ((v shr 24) and 0xff).toInt()
-      g = ((v shr 16) and 0xff).toInt()
-      b = ((v shr 8) and 0xff).toInt()
-      a = (v and 0xff).toInt()
-    }
-    return Color(red = r, green = g, blue = b, alpha = a)
-  }
-}

package/android/src/main/res/values/frame_styles.xml

@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <!-- Material theme used by all Frame host activities. Required because the Frame SDK's
-         GooglePayButton extends MaterialButton, which inflates only under a Theme.MaterialComponents
-         descendant. -->
-    <style name="Theme.Frame.NoActionBar" parent="Theme.MaterialComponents.Light.NoActionBar" />
-
-    <!-- Translucent variant for the hidden FrameGooglePayActivity host. -->
-    <style name="Theme.Frame.GooglePay.Translucent" parent="Theme.MaterialComponents.Light.NoActionBar">
-        <item name="android:windowBackground">@android:color/transparent</item>
-        <item name="android:windowIsTranslucent">true</item>
-        <item name="android:windowNoTitle">true</item>
-        <item name="android:backgroundDimEnabled">false</item>
-    </style>
-</resources>

package/ios/ApplePayPresenter.swift

@@ -1,177 +0,0 @@
-//
-//  ApplePayPresenter.swift
-//  FrameReactNative
-//
-//  Programmatic Apple Pay presentation for Frame.presentApplePay(). Wraps
-//  PKPaymentAuthorizationController + ApplePayAPI + (ChargeIntentsAPI | TransfersAPI)
-//  directly so we can detect the user-cancel path — PKPaymentAuthorizationController's
-//  didFinish fires for both success and cancel, and the underlying SDK's view
-//  model only delivers success, so we re-implement that flow here.
-//
-//  Supports both:
-//   - `.customer(id)` owner → creates a `ChargeIntent`; resolves with the ChargeIntent id.
-//   - `.account(id)`  owner → creates a `Transfer`;     resolves with the Transfer id.
-//
-
-import Foundation
-import PassKit
-import Frame
-
-@MainActor
-final class ApplePayPresenter: NSObject, PKPaymentAuthorizationControllerDelegate {
-
-  enum Owner {
-    case customer(String)
-    case account(String)
-  }
-
-  private let amount: Int
-  private let currency: String
-  private let owner: Owner
-  private let resolve: (Any?) -> Void
-  private let reject: (String, String, Error?) -> Void
-
-  // Set to true once we've delivered a definitive result (success or backend
-  // failure). When didFinish fires without this set, treat as user cancel.
-  private var didDeliverResult = false
-
-  // Strong self-retain across the async PassKit flow. Released on didFinish.
-  private var retainCycle: ApplePayPresenter?
-
-  private static let supportedNetworks: [PKPaymentNetwork] = [
-    .visa, .masterCard, .amex, .discover, .JCB
-  ]
-
-  init(amount: Int,
-       currency: String,
-       owner: Owner,
-       resolve: @escaping (Any?) -> Void,
-       reject: @escaping (String, String, Error?) -> Void) {
-    self.amount = amount
-    self.currency = currency
-    self.owner = owner
-    self.resolve = resolve
-    self.reject = reject
-  }
-
-  static func canMakePayments() -> Bool {
-    PKPaymentAuthorizationController.canMakePayments(usingNetworks: supportedNetworks)
-  }
-
-  func present() {
-    let request = PKPaymentRequest()
-    request.merchantIdentifier = FrameNetworking.shared.applePayMerchantId ?? ""
-    request.supportedNetworks = Self.supportedNetworks
-    request.merchantCapabilities = .threeDSecure
-    request.countryCode = "US"
-    request.currencyCode = currency.uppercased()
-    request.requiredBillingContactFields = [.postalAddress, .name, .emailAddress]
-    request.paymentSummaryItems = [
-      PKPaymentSummaryItem(
-        label: "Total",
-        amount: NSDecimalNumber(value: Double(amount) / 100.0)
-      )
-    ]
-
-    let controller = PKPaymentAuthorizationController(paymentRequest: request)
-    controller.delegate = self
-    retainCycle = self
-    Task { await controller.present() }
-  }
-
-  // MARK: - PKPaymentAuthorizationControllerDelegate
-
-  func paymentAuthorizationController(
-    _ controller: PKPaymentAuthorizationController,
-    didAuthorizePayment payment: PKPayment
-  ) async -> PKPaymentAuthorizationResult {
-    do {
-      // 1. Create the Frame PaymentMethod from the Apple Pay token, scoped to
-      //    whichever owner the caller asked for.
-      let (paymentMethod, methodError): (FrameObjects.PaymentMethod?, NetworkingError?)
-      switch owner {
-      case .customer(let customerId):
-        (paymentMethod, methodError) = try await ApplePayAPI.createPaymentMethodWithCustomerId(
-          from: payment, customerId: customerId
-        )
-      case .account(let accountId):
-        (paymentMethod, methodError) = try await ApplePayAPI.createPaymentMethodWithAccountId(
-          from: payment, accountId: accountId
-        )
-      }
-
-      guard let paymentMethodId = paymentMethod?.id else {
-        deliverFailure(code: "PAYMENT_METHOD_FAILED", error: methodError)
-        return PKPaymentAuthorizationResult(status: .failure, errors: nil)
-      }
-
-      // 2. Create the charge. Customer owners produce a ChargeIntent; account
-      //    owners produce a Transfer. Both surface the resulting id to JS — the
-      //    caller knows which resource the id refers to based on the owner.
-      switch owner {
-      case .customer(let customerId):
-        let request = ChargeIntentsRequests.CreateChargeIntentRequest(
-          amount: amount,
-          currency: currency,
-          customer: customerId,
-          paymentMethod: paymentMethodId,
-          confirm: true,
-          authorizationMode: .automatic
-        )
-        let (chargeIntent, chargeError) = try await ChargeIntentsAPI.createChargeIntent(request: request)
-
-        if let chargeIntent {
-          deliverSuccess(id: chargeIntent.id)
-          return PKPaymentAuthorizationResult(status: .success, errors: nil)
-        } else {
-          deliverFailure(code: "PAYMENT_FAILED", error: chargeError)
-          return PKPaymentAuthorizationResult(status: .failure, errors: nil)
-        }
-
-      case .account(let accountId):
-        let request = TransferRequests.CreateTransferRequest(
-          amount: amount,
-          accountId: accountId,
-          currency: currency,
-          sourcePaymentMethodId: paymentMethodId
-        )
-        let (transfer, transferError) = try await TransfersAPI.createTransfer(request: request)
-
-        if let transfer {
-          deliverSuccess(id: transfer.id)
-          return PKPaymentAuthorizationResult(status: .success, errors: nil)
-        } else {
-          deliverFailure(code: "PAYMENT_FAILED", error: transferError)
-          return PKPaymentAuthorizationResult(status: .failure, errors: nil)
-        }
-      }
-    } catch {
-      deliverFailure(code: "PAYMENT_FAILED", error: error)
-      return PKPaymentAuthorizationResult(status: .failure, errors: nil)
-    }
-  }
-
-  func paymentAuthorizationControllerDidFinish(_ controller: PKPaymentAuthorizationController) {
-    controller.dismiss()
-    if !didDeliverResult {
-      reject("USER_CANCELED", "User dismissed Apple Pay sheet without authorizing", nil)
-      didDeliverResult = true
-    }
-    retainCycle = nil
-  }
-
-  // MARK: - Result delivery
-
-  private func deliverSuccess(id: String) {
-    guard !didDeliverResult else { return }
-    didDeliverResult = true
-    resolve(id)
-  }
-
-  private func deliverFailure(code: String, error: Error?) {
-    guard !didDeliverResult else { return }
-    didDeliverResult = true
-    let message = error?.localizedDescription ?? "Apple Pay failed"
-    reject(code, message, error)
-  }
-}

package/ios/FramePreloader.h

@@ -1,23 +0,0 @@
-//
-//  FramePreloader.h
-//  FrameReactNative
-//
-//  Public Obj-C interface for the Swift `FramePreloader` class. Lets consumers
-//  reach `+[FramePreloader preloadOnMainThread]` from AppDelegate.mm (or any
-//  .m/.mm file) via `#import "FramePreloader.h"`, without needing modules
-//  enabled in C++ context.
-//
-
-#import <Foundation/Foundation.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@interface FramePreloader : NSObject
-
-/// Call from AppDelegate before [super application:didFinishLaunchingWithOptions:].
-/// Forces Frame (and its deps: Evervault, Sift) to load on the main thread.
-+ (void)preloadOnMainThread;
-
-@end
-
-NS_ASSUME_NONNULL_END

package/ios/FramePreloader.swift

@@ -1,28 +0,0 @@
-//
-//  FramePreloader.swift
-//  FrameReactNative
-//
-//  Preloads the Frame module on the main thread BEFORE the React Native bridge
-//  initializes. This avoids "Helpers are not supported by the default hub" crash
-//  that occurs when Frame/Evervault/Sift load on a background thread during
-//  bridge module discovery.
-//
-
-import Foundation
-import Frame
-
-@objc(FramePreloader)
-public final class FramePreloader: NSObject {
-
-    /// Call from AppDelegate before [super application:didFinishLaunchingWithOptions].
-    /// Forces Frame (and its deps: Evervault, Sift) to load on main thread.
-    @objc public static func preloadOnMainThread() {
-        guard Thread.isMainThread else {
-            DispatchQueue.main.sync { preloadOnMainThread() }
-            return
-        }
-        // Touch FrameNetworking to trigger Frame module load on main thread.
-        // Evervault/Sift config is deferred to initializeWithAPIKey.
-        _ = FrameNetworking.shared
-    }
-}