@virex-tech/paywallo-sdk 1.5.4 → 2.0.0

package/ios/PaywalloNotifications.m

@@ -0,0 +1,19 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(PaywalloNotifications, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(requestPermission:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(hasPermission:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getToken:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getInitialNotification:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/PaywalloNotifications.swift

@@ -0,0 +1,263 @@
+import Foundation
+import React
+import UserNotifications
+
+@objc(PaywalloNotifications)
+class PaywalloNotifications: RCTEventEmitter {
+
+    // MARK: - Event Names
+    private static let tokenRefreshEvent = "PaywalloTokenRefresh"
+    private static let messageReceivedEvent = "PaywalloMessageReceived"
+    private static let notificationOpenedEvent = "PaywalloNotificationOpened"
+
+    // MARK: - Pre-subscribe buffer (same pattern as PaywalloStoreKit)
+    // hasListeners is read/written from bufferQueue to avoid races between
+    // startObserving (main thread) and bufferOrEmit (NotificationCenter delivery thread).
+    private var _hasListeners = false
+    private var preSubscribeBuffer: [[String: Any]] = []
+    private let bufferQueue = DispatchQueue(label: "com.paywallo.notifications.buffer")
+    private static let maxBufferSize = 100
+
+    // MARK: - State
+    private static var latestAPNSToken: String?
+    private static var initialNotification: [String: Any]?
+
+    // MARK: - RCTEventEmitter Overrides
+
+    override static func requiresMainQueueSetup() -> Bool { return false }
+
+    override func supportedEvents() -> [String] {
+        return [
+            PaywalloNotifications.tokenRefreshEvent,
+            PaywalloNotifications.messageReceivedEvent,
+            PaywalloNotifications.notificationOpenedEvent,
+        ]
+    }
+
+    override func startObserving() {
+        bufferQueue.sync { _hasListeners = true }
+        drainPreSubscribeBuffer()
+    }
+
+    override func stopObserving() {
+        bufferQueue.sync { _hasListeners = false }
+    }
+
+    // MARK: - Buffer Management
+
+    private func bufferOrEmit(eventName: String, body: [String: Any]) {
+        // Determine whether to emit or buffer inside the lock, but never call
+        // sendEvent (which may dispatch back to main) while holding the lock —
+        // that would risk deadlock or re-entrancy on a sync queue.
+        let shouldEmit: Bool = bufferQueue.sync {
+            if _hasListeners {
+                return true
+            }
+            var entry = body
+            entry["_eventName"] = eventName
+            if preSubscribeBuffer.count >= PaywalloNotifications.maxBufferSize {
+                preSubscribeBuffer.removeFirst()
+            }
+            preSubscribeBuffer.append(entry)
+            return false
+        }
+        if shouldEmit {
+            sendEvent(withName: eventName, body: body)
+        }
+    }
+
+    private func drainPreSubscribeBuffer() {
+        // Copy and clear while holding the lock; emit outside the lock.
+        let drained: [[String: Any]] = bufferQueue.sync {
+            let copy = preSubscribeBuffer
+            preSubscribeBuffer.removeAll()
+            return copy
+        }
+        for entry in drained {
+            var body = entry
+            guard let eventName = body.removeValue(forKey: "_eventName") as? String else { continue }
+            sendEvent(withName: eventName, body: body)
+        }
+    }
+
+    // MARK: - Public Methods (exposed to JS)
+
+    @objc func requestPermission(
+        _ options: NSDictionary,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        let provisional = options["provisional"] as? Bool ?? false
+        let center = UNUserNotificationCenter.current()
+
+        var authOptions: UNAuthorizationOptions = [.alert, .sound, .badge]
+        if provisional {
+            authOptions.insert(.provisional)
+        }
+
+        center.requestAuthorization(options: authOptions) { granted, error in
+            if let error = error {
+                reject("PERMISSION_ERROR", error.localizedDescription, error)
+                return
+            }
+
+            DispatchQueue.main.async {
+                UIApplication.shared.registerForRemoteNotifications()
+            }
+
+            // Return status string matching SDK's PushPermissionStatus type
+            self.getPermissionStatusString { status in
+                resolve(status)
+            }
+        }
+    }
+
+    @objc func hasPermission(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        getPermissionStatusString { status in
+            resolve(status)
+        }
+    }
+
+    @objc func getToken(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        if let token = PaywalloNotifications.latestAPNSToken {
+            resolve(token)
+        } else {
+            resolve(nil)
+        }
+    }
+
+    @objc func getInitialNotification(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        if let notification = PaywalloNotifications.initialNotification {
+            PaywalloNotifications.initialNotification = nil // consume once
+            resolve(notification)
+        } else {
+            resolve(nil)
+        }
+    }
+
+    // MARK: - Permission Helper
+
+    private func getPermissionStatusString(completion: @escaping (String) -> Void) {
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let status: String
+            switch settings.authorizationStatus {
+            case .authorized: status = "granted"
+            case .denied: status = "denied"
+            case .provisional: status = "provisional"
+            case .notDetermined: status = "notDetermined"
+            case .ephemeral: status = "ephemeral"
+            @unknown default: status = "notDetermined"
+            }
+            completion(status)
+        }
+    }
+
+    // MARK: - Static methods called from swizzled AppDelegate
+
+    @objc static func didRegisterForRemoteNotifications(deviceToken: Data) {
+        let token = deviceToken.map { String(format: "%02x", $0) }.joined()
+        latestAPNSToken = token
+        // Emit to JS — need to find the module instance through the bridge
+        // This is handled via NotificationCenter since we can't access the bridge statically
+        NotificationCenter.default.post(
+            name: NSNotification.Name("PaywalloAPNSTokenReceived"),
+            object: nil,
+            userInfo: ["token": token]
+        )
+    }
+
+    @objc static func didReceiveRemoteNotification(userInfo: [AnyHashable: Any]) {
+        let payload = extractPayload(from: userInfo)
+        NotificationCenter.default.post(
+            name: NSNotification.Name("PaywalloRemoteNotificationReceived"),
+            object: nil,
+            userInfo: ["payload": payload]
+        )
+    }
+
+    @objc static func didOpenNotification(userInfo: [AnyHashable: Any]) {
+        let payload = extractPayload(from: userInfo)
+        // If module not ready yet, store as initial notification
+        initialNotification = payload
+        NotificationCenter.default.post(
+            name: NSNotification.Name("PaywalloNotificationOpened"),
+            object: nil,
+            userInfo: ["payload": payload]
+        )
+    }
+
+    // MARK: - Payload Extraction
+
+    private static func extractPayload(from userInfo: [AnyHashable: Any]) -> [String: Any] {
+        var payload: [String: Any] = [:]
+
+        if let aps = userInfo["aps"] as? [String: Any] {
+            if let alert = aps["alert"] as? [String: Any] {
+                payload["title"] = alert["title"] as? String ?? ""
+                payload["body"] = alert["body"] as? String ?? ""
+            } else if let alert = aps["alert"] as? String {
+                payload["body"] = alert
+            }
+        }
+
+        // Extract custom data (everything except "aps")
+        var data: [String: String] = [:]
+        for (key, value) in userInfo {
+            guard let key = key as? String, key != "aps" else { continue }
+            data[key] = "\(value)"
+        }
+        if !data.isEmpty {
+            payload["data"] = data
+        }
+
+        return payload
+    }
+
+    // MARK: - NotificationCenter observers (bridge between static calls and instance)
+
+    override init() {
+        super.init()
+        PaywalloNotificationsSwizzle.swizzleIfNeeded()
+
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onAPNSTokenReceived(_:)),
+            name: NSNotification.Name("PaywalloAPNSTokenReceived"), object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onRemoteNotificationReceived(_:)),
+            name: NSNotification.Name("PaywalloRemoteNotificationReceived"), object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self, selector: #selector(onNotificationOpened(_:)),
+            name: NSNotification.Name("PaywalloNotificationOpened"), object: nil
+        )
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc private func onAPNSTokenReceived(_ notification: Notification) {
+        guard let token = notification.userInfo?["token"] as? String else { return }
+        bufferOrEmit(eventName: PaywalloNotifications.tokenRefreshEvent, body: ["token": token])
+    }
+
+    @objc private func onRemoteNotificationReceived(_ notification: Notification) {
+        guard let payload = notification.userInfo?["payload"] as? [String: Any] else { return }
+        bufferOrEmit(eventName: PaywalloNotifications.messageReceivedEvent, body: payload)
+    }
+
+    @objc private func onNotificationOpened(_ notification: Notification) {
+        guard let payload = notification.userInfo?["payload"] as? [String: Any] else { return }
+        bufferOrEmit(eventName: PaywalloNotifications.notificationOpenedEvent, body: payload)
+    }
+}

package/ios/PaywalloNotificationsSwizzle.swift

@@ -0,0 +1,126 @@
+import Foundation
+import UIKit
+
+/// Swizzles UIApplicationDelegate methods to intercept APNS callbacks.
+/// Runs automatically at load time via swizzleIfNeeded() called from PaywalloNotifications.init().
+/// Same approach used by OneSignal, Firebase, and other push SDKs.
+@objc class PaywalloNotificationsSwizzle: NSObject {
+
+    private static var hasSwizzled = false
+
+    /// Call once at module init time to swizzle AppDelegate APNS methods.
+    @objc static func swizzleIfNeeded() {
+        guard !hasSwizzled else { return }
+
+        // Defer to main queue — UIApplication.shared.delegate is set after app launch.
+        // Set hasSwizzled only after the delegate is confirmed, so a nil-delegate
+        // early call doesn't permanently suppress swizzling.
+        DispatchQueue.main.async {
+            guard let delegate = UIApplication.shared.delegate else { return }
+            guard !hasSwizzled else { return }
+            hasSwizzled = true
+            let delegateClass: AnyClass = type(of: delegate)
+
+            swizzleDidRegisterForRemoteNotifications(delegateClass)
+            swizzleDidFailToRegisterForRemoteNotifications(delegateClass)
+            swizzleDidReceiveRemoteNotification(delegateClass)
+        }
+    }
+
+    // MARK: - didRegisterForRemoteNotificationsWithDeviceToken
+
+    private static func swizzleDidRegisterForRemoteNotifications(_ cls: AnyClass) {
+        let original = #selector(UIApplicationDelegate.application(_:didRegisterForRemoteNotificationsWithDeviceToken:))
+        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didRegisterForRemoteNotifications(_:deviceToken:))
+        swizzle(cls: cls, original: original, swizzled: swizzled)
+    }
+
+    // MARK: - didFailToRegisterForRemoteNotificationsWithError
+
+    private static func swizzleDidFailToRegisterForRemoteNotifications(_ cls: AnyClass) {
+        let original = #selector(UIApplicationDelegate.application(_:didFailToRegisterForRemoteNotificationsWithError:))
+        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didFailToRegisterForRemoteNotifications(_:error:))
+        swizzle(cls: cls, original: original, swizzled: swizzled)
+    }
+
+    // MARK: - didReceiveRemoteNotification (with completion handler)
+
+    private static func swizzleDidReceiveRemoteNotification(_ cls: AnyClass) {
+        let original = #selector(UIApplicationDelegate.application(_:didReceiveRemoteNotification:fetchCompletionHandler:))
+        let swizzled = #selector(PaywalloNotificationsSwizzle.pw_didReceiveRemoteNotification(_:userInfo:completionHandler:))
+        swizzle(cls: cls, original: original, swizzled: swizzled)
+    }
+
+    // MARK: - Core swizzle helper
+
+    /// Track whether the original method existed before swizzle for each selector,
+    /// so the pw_ implementations know whether to forward (exchange case) or not (add case).
+    private static var didExchange: [String: Bool] = [:]
+
+    /// Exchanges implementations if the method exists on cls, otherwise adds it directly.
+    private static func swizzle(cls: AnyClass, original: Selector, swizzled: Selector) {
+        guard let swizzledMethod = class_getInstanceMethod(PaywalloNotificationsSwizzle.self, swizzled) else {
+            return
+        }
+
+        let key = NSStringFromSelector(original)
+
+        if let originalMethod = class_getInstanceMethod(cls, original) {
+            // Method exists on the AppDelegate — exchange so both run.
+            // After exchange: calling `original` runs our pw_ body,
+            // calling `pw_` from within pw_ runs the ORIGINAL body (not recursion).
+            method_exchangeImplementations(originalMethod, swizzledMethod)
+            didExchange[key] = true
+        } else {
+            // Method not implemented in the host AppDelegate — add our impl directly.
+            // pw_ methods must NOT call themselves here (no original to forward to).
+            let types = method_getTypeEncoding(swizzledMethod)
+            class_addMethod(cls, original, method_getImplementation(swizzledMethod), types)
+            didExchange[key] = false
+        }
+    }
+
+    // MARK: - Swizzled implementations
+    // After method_exchangeImplementations:
+    //   - The original selector on AppDelegate points to our pw_ body
+    //   - Calling pw_ from within itself calls the ORIGINAL AppDelegate implementation
+    //     (because the IMP under pw_ was exchanged to the original). Not infinite recursion.
+    //
+    // When class_addMethod was used instead (no original method):
+    //   - There is no original to forward to, so we skip the self-call to avoid
+    //     actual infinite recursion / stack overflow.
+
+    // All pw_ methods are called on the main thread (UIApplicationDelegate callbacks
+    // are main-thread-only). didExchange is written on main by swizzleIfNeeded, so
+    // reading it here is safe without additional locking.
+
+    @objc func pw_didRegisterForRemoteNotifications(_ application: UIApplication, deviceToken: Data) {
+        PaywalloNotifications.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didRegisterForRemoteNotificationsWithDeviceToken:)))
+        if PaywalloNotificationsSwizzle.didExchange[key] == true {
+            pw_didRegisterForRemoteNotifications(application, deviceToken: deviceToken)
+        }
+    }
+
+    @objc func pw_didFailToRegisterForRemoteNotifications(_ application: UIApplication, error: Error) {
+        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didFailToRegisterForRemoteNotificationsWithError:)))
+        if PaywalloNotificationsSwizzle.didExchange[key] == true {
+            pw_didFailToRegisterForRemoteNotifications(application, error: error)
+        }
+    }
+
+    @objc func pw_didReceiveRemoteNotification(
+        _ application: UIApplication,
+        userInfo: [AnyHashable: Any],
+        completionHandler: @escaping (UIBackgroundFetchResult) -> Void
+    ) {
+        PaywalloNotifications.didReceiveRemoteNotification(userInfo: userInfo)
+        let key = NSStringFromSelector(#selector(UIApplicationDelegate.application(_:didReceiveRemoteNotification:fetchCompletionHandler:)))
+        if PaywalloNotificationsSwizzle.didExchange[key] == true {
+            pw_didReceiveRemoteNotification(application, userInfo: userInfo, completionHandler: completionHandler)
+        } else {
+            // No original handler — we must call the completion handler ourselves
+            completionHandler(.noData)
+        }
+    }
+}

package/ios/PaywalloStoreKit.m

@@ -1,6 +1,9 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(PaywalloStoreKit, NSObject)
+@interface RCT_EXTERN_MODULE(PaywalloStoreKit, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(supportedEvents)
 
 RCT_EXTERN_METHOD(getProducts:(NSArray *)productIds
                   resolve:(RCTPromiseResolveBlock)resolve

package/ios/PaywalloStoreKit.swift

@@ -1,11 +1,28 @@
 import Foundation
 import StoreKit
+import React
 
 @available(iOS 15.0, *)
 @objc(PaywalloStoreKit)
-class PaywalloStoreKit: NSObject {
+class PaywalloStoreKit: RCTEventEmitter {
 
   private var updateListenerTask: Task<Void, Never>?
+  private var hasListeners = false
+
+  // Buffer for transaction events that arrive before JS subscribes via
+  // NativeEventEmitter. StoreKit 2 starts delivering Transaction.updates
+  // as soon as the module is constructed (cold start), but JS may not
+  // have called addListener yet. Without buffering, those payloads are
+  // silently dropped and sales go untracked.
+  // In-memory only; capped at maxBufferedEvents to avoid unbounded growth.
+  private var preSubscribeBuffer: [[String: Any]] = []
+  private let bufferQueue = DispatchQueue(label: "com.paywallo.storekit.buffer")
+  private static let maxBufferedEvents = 100
+
+  // Event name emitted for every StoreKit 2 Transaction.updates signal
+  // (renewals, refunds, cancellations). JS side subscribes via
+  // NativeEventEmitter and fans the payload out to the EventBatcher.
+  private static let transactionUpdateEvent = "PaywalloTransactionUpdate"
 
   override init() {
     super.init()
@@ -16,22 +33,154 @@ class PaywalloStoreKit: NSObject {
     updateListenerTask?.cancel()
   }
 
+  // MARK: - RCTEventEmitter overrides
+
+  override func supportedEvents() -> [String]! {
+    return [PaywalloStoreKit.transactionUpdateEvent]
+  }
+
+  override func startObserving() {
+    hasListeners = true
+    drainPreSubscribeBuffer()
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(handleAppForeground),
+      name: UIApplication.didBecomeActiveNotification,
+      object: nil
+    )
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+    NotificationCenter.default.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
+  }
+
+  @objc private func handleAppForeground() {
+    guard updateListenerTask == nil || updateListenerTask!.isCancelled else { return }
+    #if DEBUG
+    print("[Paywallo:StoreKit] Restarting transaction listener after foreground")
+    #endif
+    startTransactionListener()
+  }
+
+  /// Drains any transaction events that were buffered before JS subscribed,
+  /// emitting them in FIFO order. Called from `startObserving()` once the
+  /// JS-side NativeEventEmitter has registered its listener.
+  private func drainPreSubscribeBuffer() {
+    let buffered: [[String: Any]] = bufferQueue.sync {
+      let copy = preSubscribeBuffer
+      preSubscribeBuffer.removeAll()
+      return copy
+    }
+    guard !buffered.isEmpty else { return }
+    #if DEBUG
+    print("[Paywallo:StoreKit] Draining \(buffered.count) pre-subscribe transaction event(s)")
+    #endif
+    for payload in buffered {
+      sendEvent(withName: PaywalloStoreKit.transactionUpdateEvent, body: payload)
+    }
+  }
+
+  override static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
   // MARK: - Transaction Listener
 
   private func startTransactionListener() {
     updateListenerTask = Task { [weak self] in
       for await result in Transaction.updates {
-        guard let _ = self else { return }
+        guard let self = self else { return }
         if case .verified(let transaction) = result {
           #if DEBUG
-          print("[Paywallo:StoreKit] Transaction update: \(transaction.productID) status=\(transaction.revocationDate != nil ? "revoked" : "active") id=\(transaction.id)")
+          print("[Paywallo:StoreKit] Transaction update: \(transaction.productID) revoked=\(transaction.revocationDate != nil) id=\(transaction.id)")
           #endif
+          await self.emitTransactionUpdate(transaction)
           await transaction.finish()
         }
       }
     }
   }
 
+  /// Classifies a StoreKit 2 `Transaction` coming from `Transaction.updates`
+  /// into one of three domain events — `renewed`, `refunded`, `canceled` —
+  /// and forwards a minimal payload to JS via RCTEventEmitter.
+  ///
+  /// Classification rules:
+  /// - `revocationDate != nil` + `revocationReason == .developerIssue` → `canceled`
+  /// - `revocationDate != nil` (any other reason, incl. `.other`) → `refunded`
+  /// - otherwise → `renewed` (auto-renewable subscription renewal or
+  ///   restored purchase)
+  private func emitTransactionUpdate(_ transaction: Transaction) async {
+    let type: String
+    if transaction.revocationDate != nil {
+      if let reason = transaction.revocationReason, reason == .developerIssue {
+        type = "canceled"
+      } else {
+        type = "refunded"
+      }
+    } else {
+      type = "renewed"
+    }
+
+    var payload: [String: Any] = [
+      "type": type,
+      "transactionId": String(transaction.id),
+      "productId": transaction.productID,
+    ]
+
+    // Best-effort amount + currency lookup. Products are cached on the JS
+    // side but StoreKit 2 also lets us fetch by id synchronously-ish; if
+    // the fetch fails we simply omit the fields (server-side webhook will
+    // still carry the truth).
+    if let priceInfo = await resolveProductPrice(productId: transaction.productID) {
+      payload["amount"] = priceInfo.amount
+      payload["currency"] = priceInfo.currency
+    }
+
+    if hasListeners {
+      sendEvent(withName: PaywalloStoreKit.transactionUpdateEvent, body: payload)
+    } else {
+      // JS not yet subscribed (cold-start race). Buffer up to
+      // maxBufferedEvents; drop oldest on overflow to bound memory.
+      bufferQueue.sync {
+        if preSubscribeBuffer.count >= PaywalloStoreKit.maxBufferedEvents {
+          preSubscribeBuffer.removeFirst()
+          #if DEBUG
+          print("[Paywallo:StoreKit] Pre-subscribe buffer overflow — dropping oldest event")
+          #endif
+        }
+        preSubscribeBuffer.append(payload)
+      }
+      #if DEBUG
+      print("[Paywallo:StoreKit] Buffered transaction event (no JS listener yet): \(transaction.productID)")
+      #endif
+    }
+  }
+
+  private func resolveProductPrice(productId: String) async -> (amount: Double, currency: String)? {
+    do {
+      let products = try await Product.products(for: [productId])
+      guard let product = products.first else { return nil }
+      let amount = NSDecimalNumber(decimal: product.price).doubleValue
+      var currency: String = "USD"
+      if let json = try? JSONSerialization.jsonObject(with: product.jsonRepresentation) as? [String: Any],
+         let attrs = json["attributes"] as? [String: Any],
+         let offers = attrs["offers"] as? [[String: Any]],
+         let firstOffer = offers.first,
+         let currencyCode = firstOffer["currencyCode"] as? String {
+        currency = currencyCode
+      } else if #available(iOS 16, *) {
+        currency = Locale.current.currency?.identifier ?? "USD"
+      } else {
+        currency = Locale.current.currencyCode ?? "USD"
+      }
+      return (amount, currency)
+    } catch {
+      return nil
+    }
+  }
+
   // MARK: - Get Products
 
   @objc
@@ -263,9 +412,4 @@ class PaywalloStoreKit: NSObject {
       return "P\(period.value)D"
     }
   }
-
-  @objc
-  static func requiresMainQueueSetup() -> Bool {
-    return false
-  }
 }

package/ios/PaywalloWebView.m

@@ -195,7 +195,7 @@
     // data:, and blob: — to prevent mixed-content and injection attacks.
     NSString *scheme = url.scheme.lowercaseString;
     NSSet<NSString *> *allowedSchemes = [NSSet setWithObjects:
-        @"https", @"about", @"mailto", @"itms-apps", @"itms-services", nil];
+        @"https", @"about", @"mailto", @"itms-apps", nil];
     if (scheme && ![allowedSchemes containsObject:scheme]) {
         decisionHandler(WKNavigationActionPolicyCancel);
         return;
@@ -203,8 +203,7 @@
 
     // mailto: and App Store links must be opened by the OS, not loaded inside the WebView.
     if ([scheme isEqualToString:@"mailto"] ||
-        [scheme isEqualToString:@"itms-apps"] ||
-        [scheme isEqualToString:@"itms-services"]) {
+        [scheme isEqualToString:@"itms-apps"]) {
         [[UIApplication sharedApplication] openURL:url options:@{} completionHandler:nil];
         decisionHandler(WKNavigationActionPolicyCancel);
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virex-tech/paywallo-sdk",
-  "version": "1.5.4",
+  "version": "2.0.0",
   "description": "SDK React Native para integração com Paywallo - Paywalls, Subscriptions e Analytics",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -11,7 +11,8 @@
       "react-native": "./dist/index.mjs",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -42,7 +43,9 @@
     "react-native",
     "mobile",
     "subscription",
-    "paywallo"
+    "paywallo",
+    "push-notifications",
+    "fcm"
   ],
   "author": "Virex Tech",
   "license": "MIT",
@@ -62,11 +65,15 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
+    "@react-native-firebase/app": "^22.0.0",
     "expo-tracking-transparency": "*",
     "react": "*",
     "react-native": "*"
   },
   "peerDependenciesMeta": {
+    "@react-native-firebase/app": {
+      "optional": true
+    },
     "expo-tracking-transparency": {
       "optional": true
     }
@@ -86,6 +93,6 @@
     "vitest": "^4.1.2"
   },
   "dependencies": {
-    "@virex-tech/paywallo-sdk": "^1.5.2"
+    "zod": "^4.3.6"
   }
 }