@whop/elements-react-native 0.1.0

package/ios/Sources/ElementsReactNative/WhopAuthSessionImpl.swift

@@ -0,0 +1,106 @@
+import AuthenticationServices
+import UIKit
+
+/// The redirect and 3DS surface.
+///
+/// `ASWebAuthenticationSession` runs the page in a separate process the host app can neither read
+/// nor script, which is why it is the only acceptable answer here: a `WKWebView` showing a PSP's
+/// 3DS challenge would put the issuer's page inside the app's own trust boundary.
+/// `@unchecked Sendable` with a real invariant, not a silencer: React Native may call a Turbo
+/// module off the main thread, so every method here hops to the main queue and the session state
+/// below is read and written only from there — the completion handler included, since
+/// `ASWebAuthenticationSession` does not document which queue it calls back on.
+@objc(WhopAuthSessionImpl)
+public final class WhopAuthSessionImpl: NSObject, @unchecked Sendable {
+    private var session: ASWebAuthenticationSession?
+    private var anchorProvider: AnchorProvider?
+    /// Bumped by every present(). A completion carries the value it was started with, so a late
+    /// one can tell whether the state it is about to clear is still its own.
+    private var generation = 0
+
+    @objc public func isAvailable() -> Bool {
+        true
+    }
+
+    @objc public func present(
+        _ url: String,
+        callbackScheme: String?,
+        prefersEphemeral: Bool,
+        resolve: @escaping @Sendable (Any?) -> Void,
+        reject: @escaping @Sendable (String, String) -> Void
+    ) {
+        guard let target = URL(string: url), target.scheme?.lowercased() == "https" else {
+            reject("INVALID_URL", "whop elements: an https URL is required")
+            return
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.cancel()
+            self.generation &+= 1
+            let generation = self.generation
+
+            let session = ASWebAuthenticationSession(
+                url: target,
+                callbackURLScheme: callbackScheme
+            ) { callbackURL, error in
+                // Settling and clearing on the main queue keeps this off a race with a concurrent
+                // dismiss(), which is the whole basis of the @unchecked Sendable claim above.
+                DispatchQueue.main.async { [weak self] in
+                    // Clear ONLY if this presentation is still the current one. A completion can
+                    // land after a later present() has already started a new session, and nilling
+                    // then would drop the live one: dismiss() could no longer cancel the visible
+                    // browser. Settling is unconditional, because this promise is this
+                    // presentation's however stale the presentation is.
+                    if self?.generation == generation {
+                        self?.session = nil
+                        self?.anchorProvider = nil
+                    }
+                    if let error = error as? ASWebAuthenticationSessionError,
+                       error.code == .canceledLogin
+                    {
+                        // A dismissal is an outcome, not a failure — handleNextAction's poll is the authority.
+                        resolve(nil)
+                        return
+                    }
+                    if let error {
+                        reject("AUTH_SESSION_FAILED", error.localizedDescription)
+                        return
+                    }
+                    resolve(callbackURL?.absoluteString)
+                }
+            }
+
+            let provider = AnchorProvider()
+            self.anchorProvider = provider
+            session.presentationContextProvider = provider
+            session.prefersEphemeralWebBrowserSession = prefersEphemeral
+
+            guard session.start() else {
+                self.session = nil
+                self.anchorProvider = nil
+                reject("AUTH_SESSION_FAILED", "whop elements: the system browser could not be presented")
+                return
+            }
+            self.session = session
+        }
+    }
+
+    @objc public func dismiss() {
+        DispatchQueue.main.async { [weak self] in self?.cancel() }
+    }
+
+    private func cancel() {
+        session?.cancel()
+        session = nil
+        anchorProvider = nil
+    }
+}
+
+private final class AnchorProvider: NSObject, ASWebAuthenticationPresentationContextProviding {
+    func presentationAnchor(for _: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        let active = scenes.first { $0.activationState == .foregroundActive } ?? scenes.first
+        return active?.windows.first { $0.isKeyWindow } ?? active?.windows.first ?? ASPresentationAnchor()
+    }
+}

package/ios/Sources/ElementsReactNative/WhopPayButtonImpl.swift

@@ -0,0 +1,89 @@
+import PassKit
+import UIKit
+
+/// `PKPaymentButton` itself. Apple's Human Interface Guidelines require the system control rather
+/// than a drawn imitation, which is the whole reason this element is a native view.
+@objc(WhopPayButtonImpl)
+public final class WhopPayButtonImpl: UIView {
+    @objc public var onPayPress: (() -> Void)?
+
+    private var variant: PKPaymentButtonType = .plain
+    private var style: PKPaymentButtonStyle = .automatic
+    private var radius: CGFloat = 8
+    private var isDisabled = false
+    private var button: PKPaymentButton?
+
+    @objc override public init(frame: CGRect) {
+        super.init(frame: frame)
+        rebuild()
+    }
+
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) {
+        fatalError("init(coder:) is unavailable")
+    }
+
+    override public func layoutSubviews() {
+        super.layoutSubviews()
+        button?.frame = bounds
+    }
+
+    override public var intrinsicContentSize: CGSize {
+        CGSize(width: UIView.noIntrinsicMetric, height: 48)
+    }
+
+    @objc public func setVariant(_ value: String) {
+        let next: PKPaymentButtonType
+        switch value {
+        case "buy": next = .buy
+        case "checkout": next = .checkout
+        case "book": next = .book
+        case "subscribe": next = .subscribe
+        case "order": next = .order
+        // PassKit has no `.pay`; the verb-less Apple Pay mark is `.plain`.
+        default: next = .plain
+        }
+        guard next != variant else { return }
+        variant = next
+        rebuild()
+    }
+
+    @objc public func setButtonAppearance(_ value: String) {
+        let next: PKPaymentButtonStyle
+        switch value {
+        case "light": next = .white
+        case "dark": next = .black
+        default: next = .automatic
+        }
+        guard next != style else { return }
+        style = next
+        rebuild()
+    }
+
+    @objc public func setCornerRadius(_ value: Double) {
+        radius = CGFloat(value)
+        button?.cornerRadius = radius
+    }
+
+    @objc public func setDisabled(_ value: Bool) {
+        isDisabled = value
+        button?.isEnabled = !value
+        alpha = value ? 0.5 : 1
+    }
+
+    /// PKPaymentButton takes its type and style at init only, so a prop change is a fresh button.
+    private func rebuild() {
+        button?.removeFromSuperview()
+        let next = PKPaymentButton(paymentButtonType: variant, paymentButtonStyle: style)
+        next.cornerRadius = radius
+        next.isEnabled = !isDisabled
+        next.addTarget(self, action: #selector(handlePress), for: .touchUpInside)
+        next.frame = bounds
+        addSubview(next)
+        button = next
+    }
+
+    @objc private func handlePress() {
+        onPayPress?()
+    }
+}

package/ios/Sources/ElementsReactNative/WhopPlatformPayImpl.swift

@@ -0,0 +1,181 @@
+import Contacts
+import Foundation
+import PassKit
+
+/// Apple Pay, through PassKit.
+///
+/// The web element runs a merchant-validation round trip against whop.com and refuses to render a
+/// button whose sheet is doomed, because a browser must prove the origin. PassKit replaces all of
+/// that with the app's own merchant identifier and on-device certificate, so none of those gates
+/// exist here. What crosses back is `PKPaymentToken.paymentData` — the same bytes the web path
+/// posts to Basis Theory as a token intent.
+/// `@unchecked Sendable` with a real invariant, not a silencer: React Native may call a Turbo
+/// module off the main thread, so every method here hops to the main queue and all mutable state
+/// below is read and written only from there. PassKit's own delegate callbacks arrive on the main
+/// thread too, so the invariant holds end to end.
+@objc(WhopPlatformPayImpl)
+public final class WhopPlatformPayImpl: NSObject, @unchecked Sendable {
+    private var controller: PKPaymentAuthorizationController?
+    private var pendingResolve: (@Sendable (Any?) -> Void)?
+    private var completion: ((PKPaymentAuthorizationResult) -> Void)?
+
+    @objc public func capability() -> String {
+        PKPaymentAuthorizationController.canMakePayments() ? "apple" : "none"
+    }
+
+    @objc public func canPay(
+        _ configJson: String,
+        resolve: @escaping @Sendable (Any?) -> Void,
+        reject: @escaping @Sendable (String, String) -> Void
+    ) {
+        guard let config: SheetConfig = decode(configJson) else {
+            reject("INVALID_CONFIG", "whop elements: could not decode the wallet config")
+            return
+        }
+        let networks = config.networks.compactMap(Self.network(from:))
+        resolve(PKPaymentAuthorizationController.canMakePayments(usingNetworks: networks))
+    }
+
+    @objc public func present(
+        _ requestJson: String,
+        resolve: @escaping @Sendable (Any?) -> Void,
+        reject: @escaping @Sendable (String, String) -> Void
+    ) {
+        guard let request: SheetRequest = decode(requestJson) else {
+            reject("INVALID_REQUEST", "whop elements: could not decode the wallet request")
+            return
+        }
+
+        let payment = PKPaymentRequest()
+        payment.merchantIdentifier = request.merchantIdentifier
+        payment.countryCode = request.countryCode
+        payment.currencyCode = request.currencyCode.uppercased()
+        payment.merchantCapabilities = .threeDSecure
+        payment.supportedNetworks = request.networks.compactMap(Self.network(from:))
+        payment.requiredBillingContactFields = request.requiresBillingAddress ? [.postalAddress, .name] : [.name]
+        if request.requiresEmail { payment.requiredShippingContactFields = [.emailAddress] }
+        payment.paymentSummaryItems = request.lineItems.map {
+            PKPaymentSummaryItem(label: $0.label, amount: NSDecimalNumber(string: $0.amount))
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            let controller = PKPaymentAuthorizationController(paymentRequest: payment)
+            controller.delegate = self
+            self.controller = controller
+            self.pendingResolve = resolve
+            controller.present { presented in
+                guard !presented else { return }
+                self.pendingResolve = nil
+                self.controller = nil
+                reject("SHEET_UNAVAILABLE", "whop elements: the Apple Pay sheet could not be presented")
+            }
+        }
+    }
+
+    /// The sheet's verdict follows the CONFIRM outcome, not the tokenization — a refused confirm has
+    /// to land in-sheet as a failure rather than after a checkmark.
+    @objc public func complete(_ success: Bool) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self, let completion = self.completion else { return }
+            self.completion = nil
+            completion(PKPaymentAuthorizationResult(status: success ? .success : .failure, errors: nil))
+        }
+    }
+
+    private func decode<T: Decodable>(_ json: String) -> T? {
+        guard let data = json.data(using: .utf8) else { return nil }
+        return try? JSONDecoder().decode(T.self, from: data)
+    }
+
+    private static func network(from raw: String) -> PKPaymentNetwork? {
+        switch raw.lowercased() {
+        case "visa": return .visa
+        case "mastercard", "master-card": return .masterCard
+        case "amex", "american-express": return .amex
+        case "discover": return .discover
+        case "jcb": return .JCB
+        case "maestro": return .maestro
+        case "elo": return .elo
+        case "mir": return .mir
+        case "cartes-bancaires", "cartesbancaires": return .cartesBancaires
+        default: return nil
+        }
+    }
+}
+
+extension WhopPlatformPayImpl: PKPaymentAuthorizationControllerDelegate {
+    public func paymentAuthorizationController(
+        _: PKPaymentAuthorizationController,
+        didAuthorizePayment payment: PKPayment,
+        handler: @escaping (PKPaymentAuthorizationResult) -> Void
+    ) {
+        completion = handler
+        let resolve = pendingResolve
+        pendingResolve = nil
+        resolve?(Self.envelope(for: payment))
+    }
+
+    /// The token PLUS the contact fields the sheet collected.
+    ///
+    /// Apple gathers these only because `present` asked for them, and it asks precisely when no
+    /// email or address element is mounted — so they are the only copy that exists. Returning bare
+    /// `paymentData` discarded them, and the mint then refused a buyer who had just typed their
+    /// email into the sheet.
+    private static func envelope(for payment: PKPayment) -> String {
+        let raw = String(data: payment.token.paymentData, encoding: .utf8)
+        var bag: [String: Any] = [:]
+        if let raw { bag["paymentData"] = raw }
+        if let email = payment.shippingContact?.emailAddress ?? payment.billingContact?.emailAddress {
+            bag["email"] = email
+        }
+        if let components = payment.billingContact?.name {
+            let name = PersonNameComponentsFormatter.localizedString(from: components, style: .default)
+            if !name.isEmpty { bag["name"] = name }
+        }
+        if let postal = payment.billingContact?.postalAddress {
+            var address: [String: String] = [:]
+            // CNPostalAddress.street is the whole street block, newline separated.
+            let street = postal.street.split(separator: "\n").map(String.init)
+            if let line1 = street.first, !line1.isEmpty { address["line1"] = line1 }
+            if street.count > 1 { address["line2"] = street.dropFirst().joined(separator: " ") }
+            if !postal.city.isEmpty { address["city"] = postal.city }
+            if !postal.state.isEmpty { address["state"] = postal.state }
+            if !postal.postalCode.isEmpty { address["postal_code"] = postal.postalCode }
+            if !postal.isoCountryCode.isEmpty { address["country"] = postal.isoCountryCode.uppercased() }
+            if !address.isEmpty { bag["address"] = address }
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: bag),
+              let json = String(data: data, encoding: .utf8)
+        else { return raw ?? "" }
+        return json
+    }
+
+    public func paymentAuthorizationControllerDidFinish(_ controller: PKPaymentAuthorizationController) {
+        controller.dismiss(completion: nil)
+        self.controller = nil
+        // Dismissed before authorizing: settle the promise so the JS side is never left hanging.
+        let resolve = pendingResolve
+        pendingResolve = nil
+        resolve?(nil)
+    }
+}
+
+private struct SheetConfig: Decodable {
+    let networks: [String]
+}
+
+private struct SheetRequest: Decodable {
+    struct LineItem: Decodable {
+        let label: String
+        let amount: String
+    }
+
+    let merchantIdentifier: String
+    let countryCode: String
+    let currencyCode: String
+    let networks: [String]
+    let lineItems: [LineItem]
+    let requiresBillingAddress: Bool
+    let requiresEmail: Bool
+}

package/ios/generated/WhopAddressSuggestionsModule.h

@@ -0,0 +1,11 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import <WhopElementsSpec/WhopElementsSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WhopAddressSuggestionsModule : NSObject <NativeWhopAddressSuggestionsSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/generated/WhopAddressSuggestionsModule.mm

@@ -0,0 +1,46 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import "WhopAddressSuggestionsModule.h"
+#import "WhopElementsShims.h"
+
+@implementation WhopAddressSuggestionsModule {
+  WhopAddressSuggestionsImpl *_impl;
+}
+
+// The JS name, explicitly: bare RCT_EXPORT_MODULE() registers under the CLASS name
+// ("WhopAddressSuggestionsModule"), and TurboModuleRegistry then cannot find "WhopAddressSuggestions".
+RCT_EXPORT_MODULE(WhopAddressSuggestions)
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _impl = [WhopAddressSuggestionsImpl new];
+  }
+  return self;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeWhopAddressSuggestionsSpecJSI>(params);
+}
+
+- (NSNumber *)isAvailable
+{
+  return @([_impl isAvailable]);
+}
+
+- (void)suggest:(NSString *)query resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl suggest:query resolve:^(id _Nullable value) { resolve(value); }
+               reject:^(NSString *code, NSString *message) { reject(code, message, nil); }];
+}
+
+- (void)details:(NSString *)suggestionId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl details:suggestionId resolve:^(id _Nullable value) { resolve(value); }
+               reject:^(NSString *code, NSString *message) { reject(code, message, nil); }];
+}
+
+@end

package/ios/generated/WhopAuthSessionModule.h

@@ -0,0 +1,11 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import <WhopElementsSpec/WhopElementsSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WhopAuthSessionModule : NSObject <NativeWhopAuthSessionSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/generated/WhopAuthSessionModule.mm

@@ -0,0 +1,45 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import "WhopAuthSessionModule.h"
+#import "WhopElementsShims.h"
+
+@implementation WhopAuthSessionModule {
+  WhopAuthSessionImpl *_impl;
+}
+
+// The JS name, explicitly: bare RCT_EXPORT_MODULE() registers under the CLASS name
+// ("WhopAuthSessionModule"), and TurboModuleRegistry then cannot find "WhopAuthSession".
+RCT_EXPORT_MODULE(WhopAuthSession)
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _impl = [WhopAuthSessionImpl new];
+  }
+  return self;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeWhopAuthSessionSpecJSI>(params);
+}
+
+- (NSNumber *)isAvailable
+{
+  return @([_impl isAvailable]);
+}
+
+- (void)present:(NSString *)url callbackScheme:(NSString * _Nullable)callbackScheme prefersEphemeral:(BOOL)prefersEphemeral resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl present:url callbackScheme:callbackScheme prefersEphemeral:prefersEphemeral resolve:^(id _Nullable value) { resolve(value); }
+               reject:^(NSString *code, NSString *message) { reject(code, message, nil); }];
+}
+
+- (void)dismiss
+{
+  [_impl dismiss];
+}
+
+@end

package/ios/generated/WhopElementsShims.h

@@ -0,0 +1,35 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WhopPayButtonImpl : UIView
+@property (nonatomic, copy, nullable) void (^onPayPress)(void);
+- (void)setVariant:(NSString * _Nonnull)value;
+- (void)setButtonAppearance:(NSString * _Nonnull)value;
+- (void)setCornerRadius:(double)value;
+- (void)setDisabled:(BOOL)value;
+@end
+
+@interface WhopAddressSuggestionsImpl : NSObject
+- (BOOL)isAvailable;
+- (void)suggest:(NSString *)query resolve:(void (^ _Nonnull)(id _Nullable))resolve reject:(void (^ _Nonnull)(NSString * _Nonnull, NSString * _Nonnull))reject;
+- (void)details:(NSString *)suggestionId resolve:(void (^ _Nonnull)(id _Nullable))resolve reject:(void (^ _Nonnull)(NSString * _Nonnull, NSString * _Nonnull))reject;
+@end
+
+@interface WhopAuthSessionImpl : NSObject
+- (BOOL)isAvailable;
+- (void)present:(NSString *)url callbackScheme:(NSString * _Nullable)callbackScheme prefersEphemeral:(BOOL)prefersEphemeral resolve:(void (^ _Nonnull)(id _Nullable))resolve reject:(void (^ _Nonnull)(NSString * _Nonnull, NSString * _Nonnull))reject;
+- (void)dismiss;
+@end
+
+@interface WhopPlatformPayImpl : NSObject
+- (NSString * _Nonnull)capability;
+- (void)canPay:(NSString *)configJson resolve:(void (^ _Nonnull)(id _Nullable))resolve reject:(void (^ _Nonnull)(NSString * _Nonnull, NSString * _Nonnull))reject;
+- (void)present:(NSString *)requestJson resolve:(void (^ _Nonnull)(id _Nullable))resolve reject:(void (^ _Nonnull)(NSString * _Nonnull, NSString * _Nonnull))reject;
+- (void)complete:(BOOL)success;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/generated/WhopPayButtonComponentView.h

@@ -0,0 +1,12 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WhopPayButtonComponentView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/generated/WhopPayButtonComponentView.mm

@@ -0,0 +1,82 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import "WhopPayButtonComponentView.h"
+#import "WhopElementsShims.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/WhopElementsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/WhopElementsSpec/EventEmitters.h>
+#import <react/renderer/components/WhopElementsSpec/Props.h>
+#import <react/renderer/components/WhopElementsSpec/RCTComponentViewHelpers.h>
+
+using namespace facebook::react;
+
+static NSString *WhopPayButtonVariantToString(WhopPayButtonVariant value)
+{
+  return RCTNSStringFromString(toString(value));
+}
+
+static NSString *WhopPayButtonButtonAppearanceToString(WhopPayButtonButtonAppearance value)
+{
+  return RCTNSStringFromString(toString(value));
+}
+
+@interface WhopPayButtonComponentView () <RCTWhopPayButtonViewProtocol>
+@end
+
+@implementation WhopPayButtonComponentView {
+  WhopPayButtonImpl *_impl;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<WhopPayButtonComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const WhopPayButtonProps>();
+    _props = defaultProps;
+    _impl = [[WhopPayButtonImpl alloc] initWithFrame:frame];
+    __weak __typeof(self) weakSelf = self;
+    _impl.onPayPress = ^{
+      __strong __typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf || !strongSelf->_eventEmitter) { return; }
+      std::static_pointer_cast<const WhopPayButtonEventEmitter>(strongSelf->_eventEmitter)->onPayPress({});
+    };
+    self.contentView = _impl;
+  }
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &oldViewProps = *std::static_pointer_cast<WhopPayButtonProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<WhopPayButtonProps const>(props);
+
+  if (oldViewProps.variant != newViewProps.variant) {
+    [_impl setVariant:WhopPayButtonVariantToString(newViewProps.variant)];
+  }
+  if (oldViewProps.buttonAppearance != newViewProps.buttonAppearance) {
+    [_impl setButtonAppearance:WhopPayButtonButtonAppearanceToString(newViewProps.buttonAppearance)];
+  }
+  if (oldViewProps.cornerRadius != newViewProps.cornerRadius) {
+    [_impl setCornerRadius:newViewProps.cornerRadius];
+  }
+  if (oldViewProps.disabled != newViewProps.disabled) {
+    [_impl setDisabled:newViewProps.disabled];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+@end
+
+Class<RCTComponentViewProtocol> WhopPayButtonCls(void)
+{
+  return WhopPayButtonComponentView.class;
+}

package/ios/generated/WhopPlatformPayModule.h

@@ -0,0 +1,11 @@
+// GENERATED by scripts/codegen-shims.mjs — do not edit, do not commit.
+// Source of truth: src/specs/. Implementations are Swift, in ios/Sources/WhopElements.
+
+#import <WhopElementsSpec/WhopElementsSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WhopPlatformPayModule : NSObject <NativeWhopPlatformPaySpec>
+@end
+
+NS_ASSUME_NONNULL_END