@whop/elements-react-native 0.1.0

package/android/src/main/java/com/whop/elements/WhopPayButtonView.kt

@@ -0,0 +1,178 @@
+package com.whop.elements
+
+import android.content.Context
+import android.content.res.Configuration
+import android.view.View
+import com.facebook.react.uimanager.ThemedReactContext
+import android.widget.FrameLayout
+import com.google.android.gms.wallet.button.ButtonConstants
+import com.google.android.gms.wallet.button.ButtonOptions
+import com.google.android.gms.wallet.button.PayButton
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Google's own `PayButton`, wrapped rather than subclassed: `PayButton` is `final`, so this holds
+ * one as its single child and keeps the prop state beside it.
+ *
+ * `PayButton` takes its whole configuration as one immutable options bag, so every prop change has
+ * to replay the others. The state lives on the view rather than in `setTag`, which requires a real
+ * resource id and throws on anything else.
+ */
+class WhopPayButtonView(context: Context) : FrameLayout(context) {
+
+  private var button: PayButton? = null
+  private var pressListener: View.OnClickListener? = null
+  private var rebuildScheduled = false
+
+  private var buttonType: Int = ButtonConstants.ButtonType.BUY
+  private var buttonTheme: Int = ButtonConstants.ButtonTheme.DARK
+  private var radius: Int = DEFAULT_RADIUS
+  private var themeFollowsSystem: Boolean = true
+  private var disabled: Boolean = false
+
+  init {
+    scheduleRebuild()
+  }
+
+  /** Google routes `PayButton.setOnClickListener` through its own internal handler, so the press
+   *  must be bound on the button itself rather than on this wrapper. */
+  fun setOnPressListener(listener: View.OnClickListener) {
+    pressListener = listener
+    button?.setOnClickListener(listener)
+  }
+
+  fun setVariant(value: String?) {
+    // PayButton offers a small verb set; anything else maps onto BUY, which is what Google's
+    // guidelines prescribe for a checkout action.
+    buttonType = when (value) {
+      "pay" -> ButtonConstants.ButtonType.PAY
+      "checkout" -> ButtonConstants.ButtonType.CHECKOUT
+      "book" -> ButtonConstants.ButtonType.BOOK
+      "subscribe" -> ButtonConstants.ButtonType.SUBSCRIBE
+      "order" -> ButtonConstants.ButtonType.ORDER
+      else -> ButtonConstants.ButtonType.BUY
+    }
+    scheduleRebuild()
+  }
+
+  fun setButtonAppearance(value: String?) {
+    themeFollowsSystem = value == null || value == "auto"
+    buttonTheme = when (value) {
+      "light" -> ButtonConstants.ButtonTheme.LIGHT
+      "dark" -> ButtonConstants.ButtonTheme.DARK
+      else -> systemTheme()
+    }
+    scheduleRebuild()
+  }
+
+  fun setCornerRadius(value: Double) {
+    radius = value.toInt()
+    scheduleRebuild()
+  }
+
+  fun setDisabledState(value: Boolean) {
+    disabled = value
+    applyEnabled()
+  }
+
+  override fun onConfigurationChanged(newConfig: Configuration?) {
+    super.onConfigurationChanged(newConfig)
+    if (!themeFollowsSystem) return
+    buttonTheme = systemTheme()
+    scheduleRebuild()
+  }
+
+  private fun systemTheme(): Int =
+    if ((resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) ==
+      Configuration.UI_MODE_NIGHT_YES
+    ) {
+      ButtonConstants.ButtonTheme.LIGHT
+    } else {
+      ButtonConstants.ButtonTheme.DARK
+    }
+
+  private fun applyEnabled() {
+    val current = button ?: return
+    current.isEnabled = !disabled
+    current.alpha = if (disabled) 0.5f else 1f
+  }
+
+  /**
+   * `PayButton.initialize` is documented as a once-per-instance call, and Fabric writes every prop
+   * separately right after construction. Applying each write in place meant initializing the same
+   * button four times before it was ever shown. Coalescing to one pass per frame and handing that
+   * pass a FRESH button keeps the contract without having to diff the options bag.
+   */
+  private fun scheduleRebuild() {
+    if (rebuildScheduled) return
+    rebuildScheduled = true
+    post {
+      rebuildScheduled = false
+      rebuild()
+    }
+  }
+
+  /** PayButton inflates AppCompat widgets, so it is built against the Activity where there is one. */
+  private fun hostContext(): Context = (context as? ThemedReactContext)?.currentActivity ?: context
+
+  private fun rebuild() {
+    removeAllViews()
+    val next = PayButton(hostContext())
+    next.initialize(
+      ButtonOptions.newBuilder()
+        .setButtonType(buttonType)
+        .setButtonTheme(buttonTheme)
+        .setCornerRadius(radius)
+        .setAllowedPaymentMethods(ALLOWED_METHODS)
+        .build(),
+    )
+    pressListener?.let(next::setOnClickListener)
+    button = next
+    applyEnabled()
+    addView(next, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    layoutButton()
+  }
+
+  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+    super.onLayout(changed, left, top, right, bottom)
+    layoutButton()
+  }
+
+  /**
+   * React Native lays out only the views IT created. A child added here never gets a measure pass,
+   * so `PayButton` sat at 0x0 inside a correctly sized wrapper and drew nothing — the button looked
+   * like it had failed to load when it had initialized fine. MATCH_PARENT means nothing without
+   * this, because nothing ever resolves it.
+   */
+  private fun layoutButton() {
+    val child = button ?: return
+    if (width == 0 || height == 0) return
+    child.measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY),
+    )
+    child.layout(0, 0, width, height)
+  }
+
+  companion object {
+    private const val DEFAULT_RADIUS = 8
+
+    private val ALLOWED_METHODS: String =
+      JSONArray()
+        .put(
+          JSONObject()
+            .put("type", "CARD")
+            .put(
+              "parameters",
+              JSONObject()
+                .put("allowedAuthMethods", JSONArray().put("PAN_ONLY").put("CRYPTOGRAM_3DS"))
+                .put(
+                  "allowedCardNetworks",
+                  JSONArray().put("VISA").put("MASTERCARD").put("AMEX").put("DISCOVER"),
+                ),
+            ),
+        )
+        .toString()
+  }
+}

package/android/src/main/java/com/whop/elements/WhopPlatformPayModule.kt

@@ -0,0 +1,212 @@
+package com.whop.elements
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.wallet.AutoResolveHelper
+import com.google.android.gms.wallet.IsReadyToPayRequest
+import com.google.android.gms.wallet.PaymentData
+import com.google.android.gms.wallet.PaymentDataRequest
+import com.google.android.gms.wallet.PaymentsClient
+import com.google.android.gms.wallet.Wallet
+import com.google.android.gms.wallet.WalletConstants
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Google Pay, through the Wallet API.
+ *
+ * What crosses back is `PaymentData`'s tokenization token — the same shape the web wallet lane posts
+ * to Basis Theory as a token intent, so the confirmation-token payload downstream is identical on
+ * both platforms.
+ */
+@ReactModule(name = WhopPlatformPayModule.NAME)
+class WhopPlatformPayModule(private val reactContext: ReactApplicationContext) :
+  NativeWhopPlatformPaySpec(reactContext), ActivityEventListener {
+
+  private var pending: Promise? = null
+
+  init {
+    reactContext.addActivityEventListener(this)
+  }
+
+  override fun getName(): String = NAME
+
+  override fun capability(): String = "google"
+
+  override fun canPay(configJson: String?, promise: Promise) {
+    val config = runCatching { JSONObject(configJson ?: "{}") }.getOrNull()
+    if (config == null) {
+      promise.reject("INVALID_CONFIG", "whop elements: could not decode the wallet config")
+      return
+    }
+    val request = IsReadyToPayRequest.fromJson(
+      JSONObject()
+        .put("apiVersion", 2)
+        .put("apiVersionMinor", 0)
+        .put("allowedPaymentMethods", JSONArray().put(baseCardMethod(config)))
+        .toString(),
+    )
+    client(config.optString("environment", "TEST"))
+      .isReadyToPay(request)
+      .addOnCompleteListener { task: Task<Boolean> ->
+        promise.resolve(runCatching { task.getResult(ApiExceptionClass) }.getOrDefault(false))
+      }
+  }
+
+  override fun present(requestJson: String?, promise: Promise) {
+    val request = runCatching { JSONObject(requestJson ?: "{}") }.getOrNull()
+    val activity: Activity? = reactApplicationContext.currentActivity
+    if (request == null) {
+      promise.reject("INVALID_REQUEST", "whop elements: could not decode the wallet request")
+      return
+    }
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "whop elements: no activity is attached")
+      return
+    }
+
+    pending?.resolve(null)
+    pending = promise
+
+    val payload = JSONObject()
+      .put("apiVersion", 2)
+      .put("apiVersionMinor", 0)
+      .put("allowedPaymentMethods", JSONArray().put(tokenizedCardMethod(request)))
+      .put(
+        "transactionInfo",
+        JSONObject()
+          .put("totalPrice", request.optString("totalPrice"))
+          .put("totalPriceStatus", "FINAL")
+          .put("countryCode", request.optString("countryCode"))
+          .put("currencyCode", request.optString("currencyCode").uppercase()),
+      )
+      .put("merchantInfo", JSONObject().put("merchantName", request.optString("merchantName", "Whop")))
+      .put("emailRequired", request.optBoolean("requiresEmail", false))
+
+    AutoResolveHelper.resolveTask(
+      client(request.optString("environment", "TEST"))
+        .loadPaymentData(PaymentDataRequest.fromJson(payload.toString())),
+      activity,
+      LOAD_PAYMENT_DATA,
+    )
+  }
+
+  /** Google Pay's sheet dismisses itself on result, so the confirm verdict has nothing to settle. */
+  override fun complete(success: Boolean) = Unit
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    if (requestCode != LOAD_PAYMENT_DATA) return
+    val promise = pending ?: return
+    pending = null
+    if (resultCode != Activity.RESULT_OK || data == null) {
+      promise.resolve(null)
+      return
+    }
+    val payload = PaymentData.getFromIntent(data)?.toJson()?.let(::JSONObject)
+    val token = payload
+      ?.optJSONObject("paymentMethodData")
+      ?.optJSONObject("tokenizationData")
+      ?.optString("token")
+      ?.takeIf { it.isNotEmpty() }
+    if (token == null || payload == null) {
+      promise.resolve(null)
+      return
+    }
+    promise.resolve(envelope(token, payload).toString())
+  }
+
+  /** The token PLUS whatever contact fields the sheet collected, which are otherwise discarded. */
+  private fun envelope(token: String, payload: JSONObject): JSONObject {
+    val out = JSONObject().put("paymentData", token)
+    payload.optString("email").takeIf { it.isNotEmpty() }?.let { out.put("email", it) }
+    val billing = payload
+      .optJSONObject("paymentMethodData")
+      ?.optJSONObject("info")
+      ?.optJSONObject("billingAddress")
+      ?: return out
+
+    billing.optString("name").takeIf { it.isNotEmpty() }?.let { out.put("name", it) }
+    val address = JSONObject()
+    // Google's FULL billing address: address1..address3, locality, administrativeArea, postalCode.
+    billing.optString("address1").takeIf { it.isNotEmpty() }?.let { address.put("line1", it) }
+    listOf(billing.optString("address2"), billing.optString("address3"))
+      .filter { it.isNotEmpty() }
+      .takeIf { it.isNotEmpty() }
+      ?.let { address.put("line2", it.joinToString(" ")) }
+    billing.optString("locality").takeIf { it.isNotEmpty() }?.let { address.put("city", it) }
+    billing.optString("administrativeArea").takeIf { it.isNotEmpty() }?.let { address.put("state", it) }
+    billing.optString("postalCode").takeIf { it.isNotEmpty() }?.let { address.put("postal_code", it) }
+    billing.optString("countryCode").takeIf { it.isNotEmpty() }?.let { address.put("country", it.uppercase()) }
+    if (address.length() > 0) out.put("address", address)
+    return out
+  }
+
+  override fun onNewIntent(intent: Intent) = Unit
+
+  private fun client(environment: String): PaymentsClient =
+    Wallet.getPaymentsClient(
+      reactContext,
+      Wallet.WalletOptions.Builder()
+        .setEnvironment(
+          if (environment.equals("PRODUCTION", ignoreCase = true)) {
+            WalletConstants.ENVIRONMENT_PRODUCTION
+          } else {
+            WalletConstants.ENVIRONMENT_TEST
+          },
+        )
+        .build(),
+    )
+
+  private fun baseCardMethod(config: JSONObject): JSONObject =
+    JSONObject()
+      .put("type", "CARD")
+      .put(
+        "parameters",
+        JSONObject()
+          .put("allowedAuthMethods", config.optJSONArray("allowedAuthMethods") ?: defaultAuthMethods())
+          .put("allowedCardNetworks", config.optJSONArray("allowedCardNetworks") ?: defaultNetworks()),
+      )
+
+  private fun tokenizedCardMethod(request: JSONObject): JSONObject {
+    val method = baseCardMethod(request).put(
+      "tokenizationSpecification",
+      JSONObject()
+        .put("type", "PAYMENT_GATEWAY")
+        .put(
+          "parameters",
+          JSONObject()
+            .put("gateway", request.optString("gateway"))
+            .put("gatewayMerchantId", request.optString("gatewayMerchantId")),
+        ),
+    )
+    // Mirrors iOS's requiredBillingContactFields: ask only when no address element is mounted.
+    // FULL rather than MIN, because the mint wants line1/city/state, not just a postal code.
+    if (request.optBoolean("requiresBillingAddress", false)) {
+      method.getJSONObject("parameters")
+        .put("billingAddressRequired", true)
+        .put("billingAddressParameters", JSONObject().put("format", "FULL"))
+    }
+    return method
+  }
+
+  private fun defaultAuthMethods() = JSONArray().put("PAN_ONLY").put("CRYPTOGRAM_3DS")
+
+  private fun defaultNetworks() =
+    JSONArray().put("VISA").put("MASTERCARD").put("AMEX").put("DISCOVER")
+
+  companion object {
+    const val NAME = "WhopPlatformPay"
+    /**
+     * Low 16 bits only. FragmentActivity's startActivityForResult rejects a request code with any
+     * high bit set, so the "WHOP" spelling (0x57484F50) made AutoResolveHelper throw at the moment
+     * the sheet should have opened — the tile rendered and could never complete a payment.
+     */
+    private const val LOAD_PAYMENT_DATA = 0x4F50
+    private val ApiExceptionClass = com.google.android.gms.common.api.ApiException::class.java
+  }
+}

package/ios/Package.swift

@@ -0,0 +1,59 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+/// The two relative paths below are fixed constants, not app-specific: React Native's autolinker
+/// exposes every self-managed dependency through a symlink at
+/// <appRoot>/ios/build/generated/autolinking/libs/<SwiftName>/, a known depth from the app root.
+let reactHeaders: [Target.Dependency] = [
+    .product(name: "ReactHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeHeaders", package: "ReactNative"),
+    .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+    .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+]
+
+let package = Package(
+    name: "ElementsReactNative",
+    // .v15, NOT 15.1, even though React Native declares 15.1 and generates an app target at 15.1:
+    // its autolink aggregate target is built at 15.0, and a package product demanding more than
+    // that fails to link with "requires minimum platform version 15.1 ... but this target supports
+    // 15.0". The floor a CONSUMER meets is still 15.1, set by the app target React Native writes.
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "ElementsReactNative", targets: ["ElementsReactNative", "ElementsReactNativeObjC"]),
+    ],
+    dependencies: [
+        .package(name: "ReactNative", path: "../../../../xcframeworks"),
+        .package(name: "React-GeneratedCode", path: "../../../ios"),
+    ],
+    targets: [
+        // Generated by scripts/codegen-shims.mjs. SwiftPM cannot mix languages in one target, and
+        // only the objc -> swift direction is supported, so this target must come first.
+        .target(
+            name: "ElementsReactNativeObjC",
+            dependencies: reactHeaders,
+            path: "generated",
+            publicHeadersPath: ".",
+            cSettings: [.headerSearchPath(".")],
+            cxxSettings: [
+                .headerSearchPath("."),
+                .define("DEBUG", .when(configuration: .debug)),
+                // React.xcframework has a configuration-gated C++ ABI; without this, Release links
+                // against Debug vtables and fails with undefined symbols.
+                .define("NDEBUG", .when(configuration: .release)),
+            ]
+        ),
+        .target(
+            name: "ElementsReactNative",
+            dependencies: reactHeaders + ["ElementsReactNativeObjC"],
+            path: "Sources/ElementsReactNative",
+            linkerSettings: [
+                .linkedFramework("UIKit"),
+                .linkedFramework("Foundation"),
+                .linkedFramework("PassKit"),
+                .linkedFramework("AuthenticationServices"),
+                .linkedFramework("MapKit"),
+            ]
+        ),
+    ],
+    cxxLanguageStandard: .cxx20
+)

package/ios/Sources/ElementsReactNative/WhopAddressSuggestionsImpl.swift

@@ -0,0 +1,189 @@
+import Foundation
+import MapKit
+
+/// Street suggestions from MapKit, on-device and with no API key or third-party SDK, where the web
+/// AddressElement asks Google Places.
+///
+/// This is the Turbo Module port of `MapKitAddressSuggestionProvider` in WhopUI, and it keeps that
+/// implementation's hard-won details rather than reinventing them:
+///
+///   - Listing and resolving are separate, because that is what MapKit offers.
+///     `MKLocalSearchCompleter` answers a fragment with many candidates; `MKLocalSearch` resolves
+///     ONE place and carries the address components. Using the search for the list gives a
+///     one-row list of frequently the wrong place.
+///   - MapKit does not call the delegate again for an UNCHANGED fragment, so a repeat query must
+///     return what the completer already holds or the caller waits forever.
+///   - Rows are keyed by content, not by position, so a refresh reuses a row rather than tearing it
+///     out from under a finger — and a resolve that lands after a newer query still resolves the
+///     row that was tapped.
+///
+/// `@unchecked Sendable` with a real invariant: every mutable field is touched only on the main
+/// queue, where MapKit's delegate callbacks also arrive.
+@objc(WhopAddressSuggestionsImpl)
+public final class WhopAddressSuggestionsImpl: NSObject, @unchecked Sendable {
+    private let completer = MKLocalSearchCompleter()
+    private var pending: (@Sendable (Any?) -> Void)?
+    private var completionsByID: [String: MKLocalSearchCompletion] = [:]
+    private var completionOrder: [String] = []
+    private var search: MKLocalSearch?
+
+    override public init() {
+        super.init()
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.completer.resultTypes = .address
+            self.completer.delegate = self
+        }
+    }
+
+    @objc public func isAvailable() -> Bool {
+        true
+    }
+
+    @objc public func suggest(
+        _ query: String,
+        resolve: @escaping @Sendable (Any?) -> Void,
+        reject _: @escaping @Sendable (String, String) -> Void
+    ) {
+        let trimmed = query.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmed.count >= Self.minimumQueryLength else {
+            resolve(Self.empty)
+            return
+        }
+        DispatchQueue.main.async { [weak self] in
+            guard let self else {
+                resolve(Self.empty)
+                return
+            }
+            // An unchanged fragment never fires the delegate again, so answer from what is already
+            // there. Without this a repeated query hangs until the caller gives up.
+            if self.completer.queryFragment == trimmed {
+                resolve(self.rows(from: self.completer.results))
+                return
+            }
+            // Settle the superseded query rather than leaving its promise dangling.
+            self.pending?(Self.empty)
+            self.pending = resolve
+            self.completer.queryFragment = trimmed
+        }
+    }
+
+    @objc public func details(
+        _ suggestionId: String,
+        resolve: @escaping @Sendable (Any?) -> Void,
+        reject _: @escaping @Sendable (String, String) -> Void
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self, let completion = self.completionsByID[suggestionId] else {
+                resolve(Self.emptyObject)
+                return
+            }
+            self.search?.cancel()
+            let search = MKLocalSearch(request: MKLocalSearch.Request(completion: completion))
+            self.search = search
+            search.start { response, _ in
+                guard let item = response?.mapItems.first else {
+                    resolve(Self.emptyObject)
+                    return
+                }
+                resolve(Self.components(of: item, subtitle: completion.subtitle))
+            }
+        }
+    }
+
+    private func rows(from completions: [MKLocalSearchCompletion]) -> String {
+        var rows: [[String: String]] = []
+        for completion in completions.prefix(Self.resultLimit) {
+            let id = "\(completion.title)\n\(completion.subtitle)"
+            if completionsByID.updateValue(completion, forKey: id) == nil {
+                completionOrder.append(id)
+            } else if let seen = completionOrder.firstIndex(of: id) {
+                // Insertion order alone evicts from the front, and a REPEAT hit left its id
+                // there — so a row still on screen could be trimmed, and its later tap would
+                // resolve to nothing.
+                completionOrder.remove(at: seen)
+                completionOrder.append(id)
+            }
+            let label = completion.subtitle.isEmpty
+                ? completion.title
+                : "\(completion.title), \(completion.subtitle)"
+            rows.append(["id": id, "label": label])
+        }
+        trimCompletions()
+        guard let data = try? JSONSerialization.data(withJSONObject: rows),
+              let json = String(data: data, encoding: .utf8)
+        else { return Self.empty }
+        return json
+    }
+
+    /// Bounded, so a long typing session does not grow the map without limit — but generous enough
+    /// that a resolve arriving after several newer queries still finds its row.
+    private func trimCompletions() {
+        let overflow = max(0, completionOrder.count - Self.cacheLimit)
+        guard overflow > 0 else { return }
+        for id in completionOrder.prefix(overflow) {
+            completionsByID[id] = nil
+        }
+        completionOrder.removeFirst(overflow)
+    }
+
+    /// MKMapItem.placemark is the only iOS 18 API that hands back address COMPONENTS; the iOS 26
+    /// replacements (MKAddress, MKAddressRepresentations) return formatted strings, which a form
+    /// that fills city / subdivision / postal-code fields cannot use.
+    private static func components(of item: MKMapItem, subtitle: String) -> String {
+        let placemark = item.placemark
+        var row: [String: String] = [:]
+        row["streetNumber"] = placemark.subThoroughfare ?? ""
+        row["street"] = placemark.thoroughfare ?? ""
+        // A row with no street components at all still names something usable.
+        if (placemark.subThoroughfare ?? "").isEmpty, (placemark.thoroughfare ?? "").isEmpty {
+            row["line1"] = item.name ?? ""
+        }
+        row["city"] = city(from: placemark, subtitle: subtitle) ?? ""
+        row["state"] = placemark.administrativeArea ?? ""
+        row["postalCode"] = placemark.postalCode ?? ""
+        row["country"] = placemark.isoCountryCode?.uppercased() ?? ""
+        guard let data = try? JSONSerialization.data(withJSONObject: row),
+              let json = String(data: data, encoding: .utf8)
+        else { return emptyObject }
+        return json
+    }
+
+    /// NYC boroughs all resolve to locality "New York"; a row that never names it names the real city.
+    private static func city(from placemark: MKPlacemark, subtitle: String) -> String? {
+        let components = subtitle
+            .components(separatedBy: ",")
+            .map { $0.trimmingCharacters(in: .whitespaces) }
+        let names = { (name: String) in
+            components.contains { $0 == name || $0.hasPrefix("\(name) ") }
+        }
+        if let locality = placemark.locality, names(locality) { return locality }
+        guard let state = placemark.administrativeArea,
+              let stateIndex = components.firstIndex(where: { $0 == state || $0.hasPrefix("\(state) ") }),
+              stateIndex > 0,
+              !components[stateIndex - 1].isEmpty
+        else { return placemark.locality }
+        return components[stateIndex - 1]
+    }
+
+    private static let minimumQueryLength = 3
+    private static let resultLimit = 5
+    private static let cacheLimit = 100
+    private static let empty = "[]"
+    private static let emptyObject = "{}"
+}
+
+extension WhopAddressSuggestionsImpl: MKLocalSearchCompleterDelegate {
+    public func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) {
+        let settle = pending
+        pending = nil
+        settle?(rows(from: completer.results))
+    }
+
+    public func completer(_: MKLocalSearchCompleter, didFailWithError _: Error) {
+        // A failed lookup leaves the buyer typing the address by hand, which is where they started.
+        let settle = pending
+        pending = nil
+        settle?(Self.empty)
+    }
+}