@billdog.io/react-native 1.0.0-beta.2

package/ios/BillDogLiveActivities.m

@@ -0,0 +1,41 @@
+//
+//  BillDogLiveActivities.m
+//  @billdog.io/react-native
+//
+//  RCT_EXTERN bridge declarations for the BillDogLiveActivities Swift module.
+//  iOS-only, no events. ⚠️ Requires `pod install` + Xcode (iOS 16.2+) to
+//  compile/verify — no iOS toolchain in the authoring environment.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(BillDogLiveActivities, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(areActivitiesEnabled:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(startActivity:(NSString *)activityType
+                  attributes:(NSDictionary *)attributes
+                  contentState:(NSDictionary *)contentState
+                  staleDate:(NSString *)staleDate
+                  dismissalDate:(NSString *)dismissalDate
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(updateActivity:(NSString *)activityId
+                  contentState:(NSDictionary *)contentState
+                  staleDate:(NSString *)staleDate
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(endActivity:(NSString *)activityId
+                  finalState:(NSDictionary *)finalState
+                  dismissalPolicy:(NSString *)dismissalPolicy
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getActiveActivities:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/BillDogLiveActivities.swift

@@ -0,0 +1,104 @@
+//
+//  BillDogLiveActivities.swift
+//  @billdog.io/react-native
+//
+//  React Native bridge → iOS Live Activities (ActivityKit). iOS-only, no events.
+//
+//  ⚠️ VERIFICATION: there is no iOS/CocoaPods toolchain in the authoring
+//  environment. This file REQUIRES a `pod install` + Xcode build (with an
+//  ActivityKit-capable deployment target, iOS 16.2+) to compile/verify.
+//
+//  DESIGN LIMITATION (documented, intentional no-ops):
+//  The native `LiveActivityManager` (LiveActivityManager.swift:25) exposes
+//  start/update/end/getActiveActivities as GENERICS over a concrete
+//  `ActivityAttributes` type — e.g. startActivity<Attributes: ActivityAttributes>
+//  (LiveActivityManager.swift:53). A React Native bridge only ever receives
+//  untyped JS dictionaries, so there is NO concrete ActivityAttributes /
+//  ContentState struct to instantiate at this layer. Those four methods are
+//  therefore best-effort NO-OPS (NSLog + resolve null/[]), and MUST be driven
+//  from a host-app native module that owns the concrete Attributes types.
+//  `areActivitiesEnabled` IS wired for real via ActivityKit's
+//  ActivityAuthorizationInfo (the same check at LiveActivityManager.swift:60).
+//
+
+import Foundation
+import React
+
+#if canImport(ActivityKit)
+import ActivityKit
+#endif
+
+@objc(BillDogLiveActivities)
+class BillDogLiveActivities: RCTEventEmitter {
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    // No events for this module.
+    override func supportedEvents() -> [String]! {
+        return []
+    }
+
+    // MARK: - Authorization
+
+    @objc
+    func areActivitiesEnabled(_ resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        #if canImport(ActivityKit)
+        if #available(iOS 16.2, *) {
+            // Mirrors LiveActivityManager.swift:60 — real authorization state.
+            resolve(ActivityAuthorizationInfo().areActivitiesEnabled)
+            return
+        }
+        #endif
+        resolve(false)
+    }
+
+    // MARK: - Lifecycle (documented no-ops — see file header)
+
+    @objc
+    func startActivity(_ activityType: String,
+                       attributes: NSDictionary,
+                       contentState: NSDictionary,
+                       staleDate: String?,
+                       dismissalDate: String?,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[BillDogLiveActivities] startActivity is a no-op in the RN bridge: "
+            + "the native LiveActivityManager requires a concrete ActivityAttributes "
+            + "type that cannot be built from an untyped JS payload. Drive Live "
+            + "Activities from a host-app native module. (activityType=\(activityType))")
+        resolve(nil)
+    }
+
+    @objc
+    func updateActivity(_ activityId: String,
+                        contentState: NSDictionary,
+                        staleDate: String?,
+                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[BillDogLiveActivities] updateActivity is a no-op in the RN bridge "
+            + "(generic ActivityAttributes unavailable). activityId=\(activityId)")
+        resolve(nil)
+    }
+
+    @objc
+    func endActivity(_ activityId: String,
+                     finalState: NSDictionary?,
+                     dismissalPolicy: String,
+                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[BillDogLiveActivities] endActivity is a no-op in the RN bridge "
+            + "(generic ActivityAttributes unavailable). activityId=\(activityId)")
+        resolve(nil)
+    }
+
+    @objc
+    func getActiveActivities(_ resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[BillDogLiveActivities] getActiveActivities is a no-op in the RN "
+            + "bridge (generic ActivityAttributes unavailable). Returning [].")
+        resolve([])
+    }
+}

package/ios/BillDogPaywallViewManager.m

@@ -0,0 +1,39 @@
+//
+//  BillDogPaywallViewManager.m
+//  @billdog.io/react-native
+//
+//  RCT_EXTERN bridge declarations for the BillDogPaywallViewManager Swift view
+//  manager. Exposes the inline (embedded) native paywall to React Native's
+//  legacy (Paper) architecture as `BDPaywallView` — JS resolves it via
+//  `requireNativeComponent('BDPaywallView')`.
+//
+//  ⚠️ Requires `pod install` + Xcode to compile/verify — no iOS toolchain in
+//  the authoring environment. Written to be compile-ready and internally
+//  consistent, but MUST be built against the example app before shipping.
+//
+
+#import <React/RCTViewManager.h>
+#import <React/RCTComponent.h>
+
+// Remap the JS module name so RN's view-name derivation (strip trailing
+// "Manager") yields exactly `BDPaywallView` — the name JS resolves via
+// `requireNativeComponent('BDPaywallView')` — while the Swift class stays
+// `BillDogPaywallViewManager` (see @objc(BillDogPaywallViewManager)).
+// A plain RCT_EXTERN_MODULE(BillDogPaywallViewManager, …) would instead export
+// the component as `BillDogPaywallView`, which JS does NOT look up.
+@interface RCT_EXTERN_REMAP_MODULE(BDPaywallViewManager, BillDogPaywallViewManager, RCTViewManager)
+
+// The placement / paywall identifier to load. Setting a non-empty value loads
+// and embeds the paywall (see BillDogPaywallView.paywallIdentifier didSet).
+RCT_EXPORT_VIEW_PROPERTY(paywallIdentifier, NSString)
+
+// native → JS event callbacks (RCTBubblingEventBlock).
+RCT_EXPORT_VIEW_PROPERTY(onLoaded, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPurchase, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onDismiss, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onRestore, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onOpenUrl, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onTrackEvent, RCTBubblingEventBlock)
+
+@end

package/ios/BillDogPaywallViewManager.swift

@@ -0,0 +1,361 @@
+//
+//  BillDogPaywallViewManager.swift
+//  @billdog.io/react-native
+//
+//  Inline (embedded) native paywall UIView for React Native's legacy (Paper /
+//  NON-Fabric) architecture. Exposed to JS as `BDPaywallView` via the paired
+//  RCT_EXTERN_MODULE in BillDogPaywallViewManager.m; JS resolves it with
+//  `requireNativeComponent('BDPaywallView')`.
+//
+//  NOTE: This file has NOT been compiled in this environment (no iOS toolchain /
+//  CocoaPods here). It is written to be compile-ready and internally consistent,
+//  but MUST be verified with `pod install` + an Xcode build of the example app
+//  before shipping.
+//
+//  `import BillDog` exposes every public SDK symbol (CocoaPods compiles all
+//  BillDog subspecs into a single Clang module named `BillDog`).
+//
+//  CRITICAL — purchase routing (ported from the Flutter PlatformView,
+//  packages/flutter/ios/Classes/BillDogPaywallViewFactory.swift):
+//    A raw `getPaywall(...)` VC does NOT auto-route taps into the SDK (unlike the
+//    auto-present path, which installs `InternalPaywallDelegate`). So this view
+//    sets itself as the VC delegate and MIRRORS `InternalPaywallDelegate` —
+//    executing `BillDog.shared.purchase(...)` / `restore()` on `.purchase` /
+//    `.restore`, and forwarding results back to JS as bubbling events.
+//    Reference: BillDogPaywall/UI/InternalPaywallDelegate.swift:15 (class),
+//    :24 (didReceiveAction routing).
+//
+
+import UIKit
+import React
+import BillDogFull
+
+// MARK: - View Manager
+
+@objc(BillDogPaywallViewManager)
+class BillDogPaywallViewManager: RCTViewManager {
+
+    override func view() -> UIView! {
+        return BillDogPaywallView()
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+}
+
+// MARK: - View
+
+// Conforms to `PaywallViewControllerDelegate`
+// (protocol: BillDogPaywall/UI/PaywallViewController.swift:1182).
+class BillDogPaywallView: UIView, PaywallViewControllerDelegate {
+
+    // MARK: Exported props (native → JS callbacks; RCTBubblingEventBlock)
+
+    @objc var onLoaded: RCTBubblingEventBlock?
+    @objc var onError: RCTBubblingEventBlock?
+    @objc var onPurchase: RCTBubblingEventBlock?
+    @objc var onDismiss: RCTBubblingEventBlock?
+    @objc var onRestore: RCTBubblingEventBlock?
+    @objc var onOpenUrl: RCTBubblingEventBlock?
+    @objc var onTrackEvent: RCTBubblingEventBlock?
+
+    /// The placement / paywall identifier. Loading is triggered the first time a
+    /// non-empty value is assigned (RN sets props after construction).
+    @objc var paywallIdentifier: String? {
+        didSet {
+            guard let id = paywallIdentifier, !id.isEmpty else { return }
+            guard !didStartLoad else { return }
+            didStartLoad = true
+            loadPaywall(identifier: id)
+        }
+    }
+
+    // MARK: State
+
+    /// The embedded paywall VC (retained so it — and its delegate wiring —
+    /// survives). PaywallViewController: BillDogPaywall/UI/PaywallViewController.swift:16.
+    private var paywallViewController: PaywallViewController?
+
+    /// Guards a double-load (RN can re-assign the same prop).
+    private var didStartLoad = false
+
+    /// Guards against emitting `onDismiss` twice (a `.close` action AND a
+    /// `didFinishWith(.dismissed)` lifecycle callback can both arrive).
+    private var didEmitDismiss = false
+
+    // MARK: - Loading / embedding
+
+    private func loadPaywall(identifier: String) {
+        Task { [weak self] in
+            guard let self = self else { return }
+            do {
+                // getPaywall(forPlacement:) → PaywallViewController.
+                // BillDog.swift:3243.
+                let vc = try await BillDog.shared.getPaywall(forPlacement: identifier)
+                await MainActor.run { [weak self] in
+                    self?.embed(vc)
+                }
+            } catch {
+                self.send(self.onError, ["message": error.localizedDescription])
+            }
+        }
+    }
+
+    @MainActor
+    private func embed(_ vc: PaywallViewController) {
+        self.paywallViewController = vc
+
+        // Route paywall taps/lifecycle back through this object so we can execute
+        // purchases and forward events to JS (mirrors InternalPaywallDelegate).
+        vc.delegate = self
+
+        // Add the VC's view with edge-pinned constraints.
+        let child = vc.view!
+        child.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(child)
+        NSLayoutConstraint.activate([
+            child.leadingAnchor.constraint(equalTo: leadingAnchor),
+            child.trailingAnchor.constraint(equalTo: trailingAnchor),
+            child.topAnchor.constraint(equalTo: topAnchor),
+            child.bottomAnchor.constraint(equalTo: bottomAnchor)
+        ])
+
+        // Establish a proper view-controller containment relationship when a host
+        // VC is reachable (so appearance/lifecycle + `present(...)` from the
+        // paywall work). Prefer the RN-provided ancestor VC; fall back to the
+        // front-most presented VC of the key window.
+        if let parent = reactViewController() ?? Self.nearestHostViewController() {
+            parent.addChild(vc)
+            vc.didMove(toParent: parent)
+        }
+
+        send(onLoaded, nil)
+    }
+
+    /// Best-effort walk to the front-most presented VC of the key window, used as
+    /// a fallback containment parent for the embedded paywall.
+    private static func nearestHostViewController() -> UIViewController? {
+        let window: UIWindow?
+        if #available(iOS 13.0, *) {
+            window = UIApplication.shared.connectedScenes
+                .compactMap { $0 as? UIWindowScene }
+                .flatMap { $0.windows }
+                .first(where: { $0.isKeyWindow }) ?? UIApplication.shared.windows.first(where: { $0.isKeyWindow })
+        } else {
+            window = UIApplication.shared.keyWindow
+        }
+        var top = window?.rootViewController
+        while let presented = top?.presentedViewController {
+            top = presented
+        }
+        return top
+    }
+
+    // MARK: - PaywallViewControllerDelegate
+
+    // MIRROR of BillDogPaywall/UI/InternalPaywallDelegate.swift:24 — the SDK's
+    // default routing of PaywallAction → BillDog.shared. `value` carries the
+    // action payload (productId for `.purchase`, url for `.openUrl`, etc.).
+    // PaywallAction enum + cases: PaywallViewController.swift:1197
+    //   .purchase :1198, .restore :1201, .close :1202, .openUrl :1203.
+    func paywallViewController(
+        _ controller: PaywallViewController,
+        didReceiveAction action: PaywallAction,
+        value: String
+    ) {
+        switch action {
+        case .purchase:
+            // InternalPaywallDelegate.swift:26-39 → BillDog.shared.purchase(productId:)
+            // purchase(productId:) : BillDog.swift:1375  (→ PurchaseResult, PurchaseResult.swift:24)
+            let productId = value
+            Task { [weak self] in
+                guard let self = self else { return }
+                do {
+                    let result = try await BillDog.shared.purchase(productId: productId)
+                    self.send(self.onPurchase, [
+                        "productId": Self.resolvedProductId(from: result, fallback: productId),
+                        "data": Self.purchaseData(from: result) as Any
+                    ])
+                } catch {
+                    self.send(self.onError, ["message": error.localizedDescription])
+                }
+            }
+
+        case .restore:
+            // InternalPaywallDelegate.swift:41-49 → BillDog.shared.restore()
+            // restore() : BillDog.swift:1544  (→ PurchaseResult)
+            Task { [weak self] in
+                guard let self = self else { return }
+                do {
+                    _ = try await BillDog.shared.restore()
+                    self.send(self.onRestore, nil)
+                } catch {
+                    self.send(self.onError, ["message": error.localizedDescription])
+                }
+            }
+
+        case .close:
+            // InternalPaywallDelegate.swift:51-52 dismisses the VC. Here the VC is
+            // embedded (not modally presented), so we just notify JS to tear down
+            // the view; JS owns the container lifecycle.
+            emitDismiss()
+
+        case .openUrl:
+            // InternalPaywallDelegate.swift:54-55 opens SFSafari in-app. For the
+            // embedded case we hand the URL to JS so the host app decides.
+            send(onOpenUrl, ["url": value])
+
+        case .webCheckout:
+            send(onTrackEvent, ["event": "web_checkout", "data": ["value": value]])
+
+        case .customCheckout:
+            send(onTrackEvent, ["event": "custom_checkout", "data": ["value": value]])
+
+        case .oauth(let provider):
+            // OAuth is fully handled inside PaywallViewController.handleOAuthAction
+            // before reaching the delegate (InternalPaywallDelegate.swift:76-79) —
+            // observation only.
+            send(onTrackEvent, ["event": "oauth", "data": ["provider": provider, "value": value]])
+
+        case .custom(let name):
+            send(onTrackEvent, ["event": "custom", "data": ["name": name, "value": value]])
+
+        case .openTerms:
+            send(onTrackEvent, ["event": "open_terms", "data": ["value": value]])
+
+        case .openPrivacy:
+            send(onTrackEvent, ["event": "open_privacy", "data": ["value": value]])
+
+        case .manageSubscription:
+            send(onTrackEvent, ["event": "manage_subscription", "data": ["value": value]])
+
+        case .requestRefund(let productIdentifier):
+            send(onTrackEvent, ["event": "request_refund", "data": ["productIdentifier": productIdentifier as Any, "value": value]])
+
+        case .upgradeSubscription(let currentProductIdentifier, let newProductIdentifier):
+            send(onTrackEvent, ["event": "upgrade_subscription", "data": [
+                "currentProductIdentifier": currentProductIdentifier as Any,
+                "newProductIdentifier": newProductIdentifier,
+                "value": value
+            ]])
+
+        case .downgradeSubscription(let currentProductIdentifier, let newProductIdentifier):
+            send(onTrackEvent, ["event": "downgrade_subscription", "data": [
+                "currentProductIdentifier": currentProductIdentifier as Any,
+                "newProductIdentifier": newProductIdentifier,
+                "value": value
+            ]])
+
+        case .executeAction(let actionType, let componentId, let idempotencyKey):
+            send(onTrackEvent, ["event": "execute_action", "data": [
+                "actionType": actionType,
+                "componentId": componentId,
+                "idempotencyKey": idempotencyKey as Any,
+                "value": value
+            ]])
+        }
+    }
+
+    // Lifecycle result (PaywallViewController.PaywallDismissResult:
+    // PaywallViewController.swift:118). Maps the terminal outcome to the matching
+    // JS event. `.purchased`/`.restored` are primarily driven by the action
+    // handler above (which carries richer SDK data); this path is the
+    // authoritative dismiss signal and a safety net.
+    func paywallViewController(
+        _ controller: PaywallViewController,
+        didFinishWith result: PaywallViewController.PaywallDismissResult,
+        shouldDismiss: Bool
+    ) {
+        switch result {
+        case .purchased(let productId):
+            // PaywallDismissResult.purchased(productId:) : PaywallViewController.swift:119
+            send(onPurchase, ["productId": productId, "data": NSNull()])
+        case .restored:
+            // PaywallDismissResult.restored : PaywallViewController.swift:120
+            send(onRestore, nil)
+        case .dismissed:
+            // PaywallDismissResult.dismissed : PaywallViewController.swift:121
+            emitDismiss()
+        case .oauthSuccess(let provider, let userId, let email, let name, let idToken):
+            // PaywallDismissResult.oauthSuccess : PaywallViewController.swift:122
+            send(onTrackEvent, ["event": "oauth_success", "data": [
+                "provider": provider,
+                "userId": userId as Any,
+                "email": email as Any,
+                "name": name as Any,
+                "idToken": idToken as Any
+            ]])
+        }
+
+        if shouldDismiss {
+            emitDismiss()
+        }
+    }
+
+    // Loading-state callback (PaywallViewController.PaywallLoadingState:
+    // PaywallViewController.swift:83). Observation only — `onLoaded` is emitted
+    // from `embed(_:)`.
+    func paywallViewController(
+        _ controller: PaywallViewController,
+        loadingStateDidChange state: PaywallViewController.PaywallLoadingState
+    ) { }
+
+    // MARK: - Helpers
+
+    private func emitDismiss() {
+        guard !didEmitDismiss else { return }
+        didEmitDismiss = true
+        send(onDismiss, nil)
+    }
+
+    /// Fire an RCTBubblingEventBlock on the main thread with a `[String: Any]`
+    /// payload. RN block calls must occur on the main thread.
+    private func send(_ block: RCTBubblingEventBlock?, _ payload: [String: Any]?) {
+        guard let block = block else { return }
+        let body = payload ?? [:]
+        if Thread.isMainThread {
+            block(body)
+        } else {
+            DispatchQueue.main.async {
+                block(body)
+            }
+        }
+    }
+
+    /// Resolve the productId from a PurchaseResult (PurchaseResult.swift:24),
+    /// falling back to the tapped product on non-success outcomes.
+    private static func resolvedProductId(from result: PurchaseResult, fallback: String) -> String {
+        switch result {
+        case .purchased(_, let productId, _): return productId
+        case .restored(_, let productId, _): return productId
+        default: return fallback
+        }
+    }
+
+    /// Flatten a PurchaseResult into a `[String: Any]?` payload for JS.
+    private static func purchaseData(from result: PurchaseResult) -> [String: Any]? {
+        switch result {
+        case .purchased(let transactionId, let productId, let originalTransactionId):
+            return [
+                "status": "purchased",
+                "transactionId": transactionId,
+                "productId": productId,
+                "originalTransactionId": originalTransactionId as Any
+            ]
+        case .restored(let transactionId, let productId, let originalTransactionId):
+            return [
+                "status": "restored",
+                "transactionId": transactionId,
+                "productId": productId,
+                "originalTransactionId": originalTransactionId as Any
+            ]
+        case .cancelled:
+            return ["status": "cancelled"]
+        case .pending:
+            return ["status": "pending"]
+        case .failed(let error):
+            return ["status": "failed", "error": error.localizedDescription]
+        }
+    }
+}

package/ios/BillDogSurvey.m

@@ -0,0 +1,34 @@
+//
+//  BillDogSurvey.m
+//  @billdog.io/react-native
+//
+//  RCT_EXTERN bridge declarations for the BillDogSurvey Swift module.
+//  ⚠️ Requires `pod install` + Xcode to compile/verify — no iOS toolchain in
+//  the authoring environment.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(BillDogSurvey, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(presentSurvey:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(fetchSurvey:(NSString *)surveyIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(submitResponse:(NSDictionary *)response
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(canShowSurvey:(NSString *)surveyIdentifier
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end