@usergist/feedback-react-native 0.1.0

package/ios/UserGistPushImpl.swift

@@ -0,0 +1,399 @@
+import Foundation
+import UIKit
+import UserNotifications
+
+/// Self-contained iOS push handler for `@usergist/feedback-react-native`.
+///
+/// Owns:
+///   1. UNUserNotificationCenter authorization + APNs registration.
+///   2. Capturing the APNs device token via swizzling so consumers don't
+///      have to edit `AppDelegate`.
+///   3. Foreground notification banners + tap delivery via swizzled
+///      `UNUserNotificationCenterDelegate`.
+///   4. Forwarding every signal (`tokenReceived`, `notificationReceived`,
+///      `notificationOpened`, `tokenError`) to the JS bridge.
+///
+/// `UserGistPushImpl` is a singleton. The Obj-C `UserGistPush` class binds an
+/// `RCTEventEmitter` reference at module-init time so the Swift side can
+/// emit events without owning the RN bridge type.
+@objc(UserGistPushImpl)
+public final class UserGistPushImpl: NSObject {
+
+  // MARK: - Singleton
+
+  @objc public static let shared = UserGistPushImpl()
+
+  private weak var emitter: AnyObject?
+  private let stateLock = NSLock()
+  private var hasJsListeners: Bool = false
+
+  /// Buffer of events that arrived before JS was ready to listen. Drained
+  /// the moment `startObserving` fires.
+  private var pendingEvents: [(name: String, body: [String: Any])] = []
+
+  /// The APNs token captured during the most recent registration cycle.
+  /// Cached so the JS layer can ask for it without forcing a re-prompt.
+  private var lastApnsTokenHex: String?
+
+  /// The notification (if any) the user tapped while the app was killed
+  /// — surfaced via `getInitialNotification` so the host can navigate.
+  private var initialNotification: [String: Any]?
+
+  private override init() {
+    super.init()
+  }
+
+  /// Exposed to Obj-C so UserGistPushSwizzle.m's setDelegate: interceptor
+  /// can fetch the shared UN delegate and reinstall it whenever some
+  /// other SDK (FirebaseAnalytics, OneSignal, etc.) tries to take over.
+  @objc public static func usergistUNDelegate() -> AnyObject {
+    return UserGistUNDelegateSwizzler.sharedDelegateAccessor
+  }
+
+  // MARK: - Bridge wiring
+
+  /// Called by `UserGistPush.mm -init`. Swift never imports React-Core, so we
+  /// take an opaque reference and reflect back through `@objc selector`s.
+  @objc public func bindEmitter(_ emitter: AnyObject) {
+    stateLock.lock()
+    self.emitter = emitter
+    stateLock.unlock()
+  }
+
+  @objc public func setHasJsListeners(_ value: Bool) {
+    stateLock.lock()
+    self.hasJsListeners = value
+    stateLock.unlock()
+    if value {
+      drainPendingEvents()
+    }
+  }
+
+  // MARK: - Exported (called from UserGistPush.mm)
+
+  @objc public func enablePush(options: [String: Any],
+                                resolver: @escaping (Any?) -> Void,
+                                rejecter: @escaping (String, String, Error?) -> Void) {
+    NSLog("[UserGistPush] enablePush called")
+    let installDelegateProxy = options["installDelegateProxy"] as? Bool ?? true
+    if installDelegateProxy {
+      Self.installUNDelegateSwizzleIfNeeded()
+      if let swizzler: AnyClass = NSClassFromString("UserGistPushSwizzle") {
+        let selector = NSSelectorFromString("installIfNeeded")
+        let target = swizzler as AnyObject
+        if target.responds(to: selector) {
+          _ = target.perform(selector)
+        }
+      }
+    }
+    UNUserNotificationCenter.current().requestAuthorization(
+      options: [.alert, .badge, .sound, .providesAppNotificationSettings]
+    ) { [weak self] granted, error in
+      NSLog("[UserGistPush] requestAuthorization callback granted=\(granted) error=\(String(describing: error))")
+      if let error = error {
+        rejecter("auth_error", error.localizedDescription, error)
+        return
+      }
+      let status: String = granted ? "authorized" : "denied"
+      DispatchQueue.main.async {
+        if granted {
+          NSLog("[UserGistPush] calling UIApplication.registerForRemoteNotifications")
+          UIApplication.shared.registerForRemoteNotifications()
+        }
+        // Token arrives asynchronously via the swizzled
+        // `application:didRegisterForRemoteNotificationsWithDeviceToken:`
+        // callback. Resolve immediately with whatever we have cached so the
+        // caller has a result even if the token is still in flight; the
+        // `tokenReceived` event will fire shortly with the value.
+        resolver([
+          "granted": granted,
+          "status": status,
+          "token": self?.readLastApnsToken() as Any,
+          "platform": "ios"
+        ])
+      }
+    }
+  }
+
+  @objc public func disablePush(resolver: @escaping (Any?) -> Void,
+                                 rejecter: @escaping (String, String, Error?) -> Void) {
+    DispatchQueue.main.async {
+      UIApplication.shared.unregisterForRemoteNotifications()
+      self.stateLock.lock()
+      self.lastApnsTokenHex = nil
+      self.stateLock.unlock()
+      resolver(nil)
+    }
+  }
+
+  @objc public func getPermissionStatus(resolver: @escaping (Any?) -> Void,
+                                         rejecter: @escaping (String, String, Error?) -> Void) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+      let s: String
+      switch settings.authorizationStatus {
+      case .authorized: s = "authorized"
+      case .denied: s = "denied"
+      case .notDetermined: s = "not_determined"
+      case .provisional: s = "provisional"
+      case .ephemeral: s = "authorized"
+      @unknown default: s = "not_determined"
+      }
+      resolver(s)
+    }
+  }
+
+  @objc public func setBadgeCount(_ count: Double,
+                                   resolver: @escaping (Any?) -> Void,
+                                   rejecter: @escaping (String, String, Error?) -> Void) {
+    DispatchQueue.main.async {
+      let center = UNUserNotificationCenter.current()
+      let n = Int(count)
+      if #available(iOS 16.0, *) {
+        center.setBadgeCount(n) { error in
+          if let error = error {
+            rejecter("badge_failed", error.localizedDescription, error)
+          } else {
+            resolver(nil)
+          }
+        }
+      } else {
+        UIApplication.shared.applicationIconBadgeNumber = n
+        resolver(nil)
+      }
+    }
+  }
+
+  @objc public func getInitialNotification(resolver: @escaping (Any?) -> Void,
+                                            rejecter: @escaping (String, String, Error?) -> Void) {
+    stateLock.lock()
+    let notification = initialNotification
+    initialNotification = nil
+    stateLock.unlock()
+    resolver(notification as Any?)
+  }
+
+  // MARK: - Internal — emission helpers (called from swizzles)
+
+  @objc public func recordToken(deviceToken: Data) {
+    let hex = deviceToken.map { String(format: "%02x", $0) }.joined()
+    NSLog("[UserGistPush] APNs token received (\(hex.count) hex chars) — emitting tokenReceived")
+    stateLock.lock()
+    lastApnsTokenHex = hex
+    stateLock.unlock()
+    emit(name: "UserGistPush:tokenReceived", body: ["token": hex, "platform": "ios"])
+  }
+
+  @objc public func recordTokenError(error: Error) {
+    NSLog("[UserGistPush] APNs registration FAILED: \(error.localizedDescription)")
+    emit(name: "UserGistPush:tokenError",
+         body: ["error": error.localizedDescription])
+  }
+
+  func recordNotificationReceived(userInfo: [AnyHashable: Any]) {
+    let normalized = normalizeUserInfo(userInfo)
+    emit(name: "UserGistPush:notificationReceived", body: normalized)
+  }
+
+  func recordNotificationOpened(userInfo: [AnyHashable: Any], actionIdentifier: String?) {
+    var body = normalizeUserInfo(userInfo)
+    if let actionIdentifier = actionIdentifier, actionIdentifier != "com.apple.UNNotificationDefaultActionIdentifier" {
+      body["actionIdentifier"] = actionIdentifier
+    }
+    stateLock.lock()
+    if initialNotification == nil {
+      // First open captured — surface via getInitialNotification.
+      initialNotification = body
+    }
+    stateLock.unlock()
+    emit(name: "UserGistPush:notificationOpened", body: body)
+  }
+
+  // MARK: - Internal — emit + normalize
+
+  private func emit(name: String, body: [String: Any]) {
+    stateLock.lock()
+    guard hasJsListeners else {
+      NSLog("[UserGistPush] emit BUFFER \(name) — JS not listening yet (pending=\(pendingEvents.count + 1))")
+      if pendingEvents.count >= 100 { pendingEvents.removeFirst() }
+      pendingEvents.append((name, body))
+      stateLock.unlock()
+      return
+    }
+    stateLock.unlock()
+    NSLog("[UserGistPush] emit SEND \(name)")
+    sendToEmitter(name: name, body: body)
+  }
+
+  private func drainPendingEvents() {
+    stateLock.lock()
+    let buffered = pendingEvents
+    pendingEvents = []
+    stateLock.unlock()
+    for ev in buffered {
+      sendToEmitter(name: ev.name, body: ev.body)
+    }
+  }
+
+  private func sendToEmitter(name: String, body: [String: Any]) {
+    stateLock.lock()
+    let target = emitter
+    stateLock.unlock()
+    guard let emitter = target else { return }
+    // RCTEventEmitter exposes `sendEventWithName:body:`. Reflect to call
+    // it without importing React-Core in Swift (keeps the Swift module
+    // free of React headers, which simplifies new-arch interop).
+    let sel = NSSelectorFromString("sendEventWithName:body:")
+    guard emitter.responds(to: sel) else { return }
+    _ = emitter.perform(sel, with: name, with: body as NSDictionary)
+  }
+
+  private func readLastApnsToken() -> String? {
+    stateLock.lock()
+    defer { stateLock.unlock() }
+    return lastApnsTokenHex
+  }
+
+  private func normalizeUserInfo(_ userInfo: [AnyHashable: Any]) -> [String: Any] {
+    var out: [String: Any] = [:]
+    var aps: [String: Any]?
+    var data: [String: Any] = [:]
+    for (k, v) in userInfo {
+      guard let key = k as? String else { continue }
+      if key == "aps", let dict = v as? [String: Any] {
+        aps = dict
+      } else {
+        data[key] = v
+      }
+    }
+    if let alert = aps?["alert"] as? [String: Any] {
+      if let title = alert["title"] as? String { out["title"] = title }
+      if let body = alert["body"] as? String { out["body"] = body }
+    } else if let alertString = aps?["alert"] as? String {
+      out["body"] = alertString
+    }
+    out["data"] = data
+    // delivery_id can land in three places depending on payload shape:
+    //   1. flat   data["usergist_delivery_id"]   — FCM data-only path
+    //   2. flat   data["delivery_id"]          — legacy / generic path
+    //   3. nested data["usergist"]["deliveryId"] — current APNs payload
+    // Without fallback (3), iOS opens land with deliveryId=nil and the
+    // server-side patcher early-returns → opened_at never updates.
+    let nestedUserGist = data["usergist"] as? [String: Any]
+    if let deliveryId =
+      (data["delivery_id"] as? String)
+      ?? (data["usergist_delivery_id"] as? String)
+      ?? (nestedUserGist?["deliveryId"] as? String)
+    {
+      out["deliveryId"] = deliveryId
+    }
+    if let actionId = nestedUserGist?["actionIdentifier"] as? String {
+      // Carry a server-set action id through if present (none today, future-proof).
+      out["actionIdentifier"] = actionId
+    }
+    return out
+  }
+
+  // MARK: - UN delegate swizzle install
+
+  private static var unDelegateInstalled = false
+
+  private static func installUNDelegateSwizzleIfNeeded() {
+    guard !unDelegateInstalled else { return }
+    unDelegateInstalled = true
+    // Install synchronously after enablePush opts into automatic integration.
+    UserGistUNDelegateSwizzler.install()
+    // Re-install whenever the app foregrounds. Belt-and-braces against
+    // any SDK that re-takes the delegate while the app is backgrounded.
+    NotificationCenter.default.addObserver(
+      forName: UIApplication.didBecomeActiveNotification,
+      object: nil,
+      queue: .main,
+    ) { _ in
+      UserGistUNDelegateSwizzler.reinstallIfHijacked()
+    }
+  }
+}
+
+// MARK: - AppDelegate swizzler (APNs token capture)
+
+// AppDelegate APNs swizzle has moved to UserGistPushSwizzle.m (pure Obj-C,
+// installed via +load + UIApplicationDidFinishLaunchingNotification so it
+// lands before any iOS push registration cycle). The Obj-C bridge calls
+// `[UserGistPushImpl.shared recordTokenWithDeviceToken:]` /
+// `recordTokenErrorWithError:` from the swizzled IMP.
+
+// MARK: - UNUserNotificationCenterDelegate swizzler (foreground + open)
+
+@objc private final class UserGistUNDelegateSwizzler: NSObject, UNUserNotificationCenterDelegate {
+
+  fileprivate static let sharedDelegate = UserGistUNDelegateSwizzler()
+  /// Public access to the shared instance for the Obj-C swizzle bridge.
+  @objc fileprivate static var sharedDelegateAccessor: AnyObject { return sharedDelegate }
+  private weak var existingDelegate: UNUserNotificationCenterDelegate?
+
+  fileprivate static func install() {
+    let center = UNUserNotificationCenter.current()
+    if let existing = center.delegate, existing !== sharedDelegate {
+      sharedDelegate.existingDelegate = existing
+    }
+    center.delegate = sharedDelegate
+    NSLog("[UserGistPush] UN delegate installed (chained=\(sharedDelegate.existingDelegate != nil))")
+  }
+
+  /// Re-install if some other SDK has stolen the delegate since we last set it.
+  /// Called on every foreground transition.
+  fileprivate static func reinstallIfHijacked() {
+    let center = UNUserNotificationCenter.current()
+    guard center.delegate !== sharedDelegate else { return }
+    NSLog("[UserGistPush] delegate hijacked by \(String(describing: type(of: center.delegate))) — reinstalling")
+    if let existing = center.delegate, existing !== sharedDelegate {
+      sharedDelegate.existingDelegate = existing
+    }
+    center.delegate = sharedDelegate
+  }
+
+  /// Resolve the foreign delegate to chain to: prefer the most recent one
+  /// captured by the Obj-C setDelegate: interceptor (catches Firebase /
+  /// OneSignal / etc. that install AFTER our swizzle ran), fall back to
+  /// whatever was on the center when our swizzle first installed.
+  private func chainTarget() -> UNUserNotificationCenterDelegate? {
+    if let foreign = _UserGistGetLastForeignDelegate() as? UNUserNotificationCenterDelegate,
+       foreign !== self {
+      return foreign
+    }
+    return existingDelegate
+  }
+
+  // Foreground delivery
+  func userNotificationCenter(_ center: UNUserNotificationCenter,
+                              willPresent notification: UNNotification,
+                              withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+    UserGistPushImpl.shared.recordNotificationReceived(userInfo: notification.request.content.userInfo)
+    if let existing = chainTarget(),
+       existing.responds(to: #selector(UNUserNotificationCenterDelegate.userNotificationCenter(_:willPresent:withCompletionHandler:))) {
+      existing.userNotificationCenter?(center, willPresent: notification, withCompletionHandler: completionHandler)
+      return
+    }
+    if #available(iOS 14.0, *) {
+      completionHandler([.banner, .list, .sound, .badge])
+    } else {
+      completionHandler([.alert, .sound, .badge])
+    }
+  }
+
+  // Tap / action
+  func userNotificationCenter(_ center: UNUserNotificationCenter,
+                              didReceive response: UNNotificationResponse,
+                              withCompletionHandler completionHandler: @escaping () -> Void) {
+    UserGistPushImpl.shared.recordNotificationOpened(
+      userInfo: response.notification.request.content.userInfo,
+      actionIdentifier: response.actionIdentifier
+    )
+    if let existing = chainTarget(),
+       existing.responds(to: #selector(UNUserNotificationCenterDelegate.userNotificationCenter(_:didReceive:withCompletionHandler:))) {
+      existing.userNotificationCenter?(center, didReceive: response, withCompletionHandler: completionHandler)
+      return
+    }
+    completionHandler()
+  }
+}

package/ios/UserGistPushSwizzle.m

@@ -0,0 +1,168 @@
+// Pure Obj-C swizzle for capturing the APNs device token from the host
+// app's UIApplicationDelegate without requiring any AppDelegate edits.
+//
+// Why Obj-C: Swift methods even with `@objc dynamic` go through Swift's
+// vtable thunking. When method_getImplementation returns the IMP, calling
+// it on a `self` of a different class can hit Swift-specific guards that
+// silently no-op the call. A bare Obj-C IMP installed via
+// `imp_implementationWithBlock` has the standard objc_msgSend ABI and runs
+// on any NSObject subclass without surprises.
+//
+// Installation is explicit and happens only after the host calls enablePush.
+// At that point UIApplication already has a delegate, and interception is in
+// place before registerForRemoteNotifications starts the APNs token cycle.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <UserNotifications/UserNotifications.h>
+#import <objc/runtime.h>
+#import <objc/message.h>
+
+#if __has_include("UserGistFeedback-Swift.h")
+#import "UserGistFeedback-Swift.h"
+#else
+#import <UserGistFeedback/UserGistFeedback-Swift.h>
+#endif
+
+@interface UserGistPushSwizzle : NSObject
+@end
+
+@implementation UserGistPushSwizzle
+
++ (void)load { }
+
++ (void)installIfNeeded {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+    [self installUNDelegateSetterSwizzle];
+
+    // Force-instantiate the Swift singleton so its `init` runs and our
+    // shared UN delegate is available the very first time the setter
+    // swizzle fires. Otherwise the first foreign `setDelegate:` call
+    // (typically Firebase) would still hit the original setter because
+    // usergistUNDelegate() returned nil.
+    Class implCls = NSClassFromString(@"UserGistFeedback.UserGistPushImpl");
+    if (!implCls) implCls = NSClassFromString(@"UserGistPushImpl");
+    if (implCls) {
+        SEL sharedSel = NSSelectorFromString(@"shared");
+        if ([implCls respondsToSelector:sharedSel]) {
+            (void)((id (*)(id, SEL))objc_msgSend)(implCls, sharedSel);
+            NSLog(@"[UserGistPush] +load: UserGistPushImpl.shared force-initialized");
+        }
+    }
+
+    [self _usergistInstallSwizzles:nil];
+    });
+}
+
++ (void)_usergistInstallSwizzles:(NSNotification *)note {
+    Class delegateClass = [[[UIApplication sharedApplication] delegate] class];
+    if (!delegateClass) {
+        NSLog(@"[UserGistPush] opt-in swizzle: no AppDelegate — skipping");
+        return;
+    }
+    NSLog(@"[UserGistPush] opt-in swizzle: target class = %@", NSStringFromClass(delegateClass));
+
+    [self installDidRegister:delegateClass];
+    [self installDidFail:delegateClass];
+
+    NSLog(@"[UserGistPush] opt-in swizzle: complete");
+}
+
+// Holds whoever the host (or another SDK like FirebaseAnalytics) most
+// recently tried to install as the UNUserNotificationCenter delegate.
+// Read by UserGistUNDelegateSwizzler so it can chain didReceive / willPresent
+// to the displaced delegate.
+static __weak id<NSObject> _usergist_lastForeignDelegate = nil;
+
+// Swizzle UNUserNotificationCenter.setDelegate: so any code that tries to
+// install its own delegate (FirebaseAnalytics, OneSignal, Notifee, the
+// host app itself) is intercepted. Their delegate is captured as the
+// "foreign" chain target; our shared delegate stays installed.
++ (void)installUNDelegateSetterSwizzle {
+    Class cls = [UNUserNotificationCenter class];
+    SEL setterSel = @selector(setDelegate:);
+    Method existing = class_getInstanceMethod(cls, setterSel);
+    if (!existing) {
+        NSLog(@"[UserGistPush] setDelegate: not found on UNUserNotificationCenter — skipping");
+        return;
+    }
+    IMP origImp = method_getImplementation(existing);
+    IMP newImp = imp_implementationWithBlock(
+        ^(UNUserNotificationCenter *_self, id<NSObject> incoming) {
+            // Pull the Swift-side shared delegate via the public Swift class.
+            // UserGistFeedback-Swift.h exposes UserGistPushImpl; we route through
+            // it to install + record the foreign chain target.
+            Class implCls = NSClassFromString(@"UserGistFeedback.UserGistPushImpl");
+            if (!implCls) implCls = NSClassFromString(@"UserGistPushImpl");
+            id sharedDelegate = nil;
+            if (implCls) {
+                SEL usergistSharedSel = NSSelectorFromString(@"usergistUNDelegate");
+                if ([implCls respondsToSelector:usergistSharedSel]) {
+                    sharedDelegate = ((id (*)(id, SEL))objc_msgSend)(implCls, usergistSharedSel);
+                }
+            }
+            if (incoming && sharedDelegate && incoming != sharedDelegate) {
+                NSLog(@"[UserGistPush] setDelegate: foreign=%@, keeping ours; chain target captured",
+                      NSStringFromClass([incoming class]));
+                _usergist_lastForeignDelegate = incoming;
+                ((void (*)(id, SEL, id))origImp)(_self, setterSel, sharedDelegate);
+                return;
+            }
+            ((void (*)(id, SEL, id))origImp)(_self, setterSel, incoming);
+        });
+    method_setImplementation(existing, newImp);
+    NSLog(@"[UserGistPush] UN setDelegate swizzle installed");
+}
+
+// Exposed to Swift via the bridging header — the Swift swizzler reads this
+// when chaining didReceive / willPresent.
+NSObject *_UserGistGetLastForeignDelegate(void) {
+    return (NSObject *)_usergist_lastForeignDelegate;
+}
+
++ (void)installDidRegister:(Class)cls {
+    SEL sel = @selector(application:didRegisterForRemoteNotificationsWithDeviceToken:);
+    IMP newImp = imp_implementationWithBlock(^(id _self, UIApplication *app, NSData *deviceToken) {
+        NSLog(@"[UserGistPush] swizzled didRegister fired (token len=%lu)",
+              (unsigned long)deviceToken.length);
+        [[UserGistPushImpl shared] recordTokenWithDeviceToken:deviceToken];
+        // Chain — if the original delegate had its own impl we replaced, the
+        // exchanged IMP lives under sel `_usergist_orig_didRegister:`.
+        SEL chainSel = NSSelectorFromString(@"_usergist_orig_application:didRegisterForRemoteNotificationsWithDeviceToken:");
+        if ([_self respondsToSelector:chainSel]) {
+            ((void (*)(id, SEL, UIApplication *, NSData *))objc_msgSend)(_self, chainSel, app, deviceToken);
+        }
+    });
+    Method existing = class_getInstanceMethod(cls, sel);
+    if (existing) {
+        // Save the original under a different selector so we can chain.
+        SEL chainSel = NSSelectorFromString(@"_usergist_orig_application:didRegisterForRemoteNotificationsWithDeviceToken:");
+        class_addMethod(cls, chainSel, method_getImplementation(existing), method_getTypeEncoding(existing));
+        method_setImplementation(existing, newImp);
+    } else {
+        class_addMethod(cls, sel, newImp, "v@:@@");
+    }
+}
+
++ (void)installDidFail:(Class)cls {
+    SEL sel = @selector(application:didFailToRegisterForRemoteNotificationsWithError:);
+    IMP newImp = imp_implementationWithBlock(^(id _self, UIApplication *app, NSError *err) {
+        NSLog(@"[UserGistPush] swizzled didFail fired: %@", err.localizedDescription);
+        [[UserGistPushImpl shared] recordTokenErrorWithError:err];
+        SEL chainSel = NSSelectorFromString(@"_usergist_orig_application:didFailToRegisterForRemoteNotificationsWithError:");
+        if ([_self respondsToSelector:chainSel]) {
+            ((void (*)(id, SEL, UIApplication *, NSError *))objc_msgSend)(_self, chainSel, app, err);
+        }
+    });
+    Method existing = class_getInstanceMethod(cls, sel);
+    if (existing) {
+        SEL chainSel = NSSelectorFromString(@"_usergist_orig_application:didFailToRegisterForRemoteNotificationsWithError:");
+        class_addMethod(cls, chainSel, method_getImplementation(existing), method_getTypeEncoding(existing));
+        method_setImplementation(existing, newImp);
+    } else {
+        class_addMethod(cls, sel, newImp, "v@:@@");
+    }
+}
+
+@end

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@usergist/feedback-react-native",
+  "version": "0.1.0",
+  "description": "userGist feedback + push SDK for React Native (self-contained, no Firebase/OneSignal/WonderPush required)",
+  "license": "MIT",
+  "homepage": "https://usergist.com/docs/sdks/react-native",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Future-Picnic/usergist-js.git",
+    "directory": "packages/sdk-react-native"
+  },
+  "bugs": {
+    "url": "https://github.com/Future-Picnic/usergist-js/issues"
+  },
+  "keywords": [
+    "react-native",
+    "feedback",
+    "surveys",
+    "push-notifications",
+    "in-app-messaging",
+    "feature-requests"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./preview": {
+      "types": "./dist/preview/index.d.ts",
+      "import": "./dist/preview/index.js",
+      "default": "./dist/preview/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "!dist/Ritmus*",
+    "!dist/NativeRitmusPush*",
+    "ios",
+    "android",
+    "!android/build",
+    "UserGistFeedback.podspec",
+    "UserGistFeedbackExtension.podspec",
+    "react-native.config.js",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.19",
+    "react": ">=18",
+    "react-native": ">=0.72",
+    "react-native-safe-area-context": ">=4"
+  },
+  "dependencies": {
+    "@usergist/sdk-core": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "react": "18.2.0",
+    "react-native": "0.74.0",
+    "react-native-safe-area-context": "^4",
+    "vitest": "^2.1.0",
+    "typescript": "^5.5.4"
+  },
+  "codegenConfig": {
+    "name": "RNUserGistPushSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "studio.usergist.feedback"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "pack:check": "pnpm publish --dry-run --no-git-checks"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,16 @@
+// React Native autolinking entry. RN 0.60+ reads this to discover the
+// native iOS Pod and Android Gradle module without consumer-side edits.
+export default {
+  dependency: {
+    platforms: {
+      ios: {
+        // The podspec at repo root pulls ios/ sources via s.source_files.
+      },
+      android: {
+        sourceDir: 'android',
+        packageImportPath: 'import studio.usergist.feedback.UserGistPushPackage;',
+        packageInstance: 'new UserGistPushPackage()',
+      },
+    },
+  },
+}