@entrig/react-native 0.0.1

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/ios/EntrigAppDelegate.swift

@@ -0,0 +1,58 @@
+import UIKit
+import UserNotifications
+import EntrigSDK
+
+/// Helper class that wires up the iOS AppDelegate hooks required by the Entrig SDK.
+///
+/// **For Expo users**: The config plugin (`app.plugin.js`) injects these hooks
+/// at prebuild time, so this file is not used.
+///
+/// **For bare React Native users**: Call `EntrigAppDelegate.setup(launchOptions:)`
+/// from your AppDelegate's `didFinishLaunchingWithOptions` and forward the
+/// other delegate methods as shown below.
+///
+/// ```swift
+/// // AppDelegate.swift
+/// import EntrigSDK
+///
+/// @main
+/// class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {
+///   func application(_ application: UIApplication,
+///                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+///     UNUserNotificationCenter.current().delegate = self
+///     EntrigAppDelegate.setup(launchOptions: launchOptions)
+///     return true
+///   }
+///
+///   func application(_ application: UIApplication,
+///                    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+///     Entrig.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+///   }
+///
+///   func application(_ application: UIApplication,
+///                    didFailToRegisterForRemoteNotificationsWithError error: Error) {
+///     Entrig.didFailToRegisterForRemoteNotifications(error: error)
+///   }
+///
+///   func userNotificationCenter(_ center: UNUserNotificationCenter,
+///                               willPresent notification: UNNotification,
+///                               withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+///     Entrig.willPresentNotification(notification)
+///     completionHandler(Entrig.getPresentationOptions())
+///   }
+///
+///   func userNotificationCenter(_ center: UNUserNotificationCenter,
+///                               didReceive response: UNNotificationResponse,
+///                               withCompletionHandler completionHandler: @escaping () -> Void) {
+///     Entrig.didReceiveNotification(response)
+///     completionHandler()
+///   }
+/// }
+/// ```
+@objc public class EntrigAppDelegate: NSObject {
+
+  /// Call from `didFinishLaunchingWithOptions` to check for cold-start notifications.
+  @objc public static func setup(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+    Entrig.checkLaunchNotification(launchOptions)
+  }
+}

package/ios/EntrigModule.m

@@ -0,0 +1,24 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(Entrig, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)config
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(register:(NSString *)userId
+                  withIsDebug:(NSNumber *)isDebug
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(requestPermission:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(unregister:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getInitialNotification:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/EntrigModule.swift

@@ -0,0 +1,138 @@
+import React
+import UserNotifications
+import EntrigSDK
+
+@objc(Entrig)
+class EntrigModule: RCTEventEmitter {
+  private var hasListeners = false
+
+  override func supportedEvents() -> [String]! {
+    return ["onForegroundNotification", "onNotificationOpened"]
+  }
+
+  override class func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  override func startObserving() {
+    hasListeners = true
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+  }
+
+  @objc(initialize:withResolver:withRejecter:)
+  func initializeSDK(config: [String: Any], resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    guard let apiKey = config["apiKey"] as? String, !apiKey.isEmpty else {
+      rejecter("INVALID_API_KEY", "API key is required and cannot be empty", nil)
+      return
+    }
+
+    let handlePermission = config["handlePermission"] as? Bool ?? true
+    let showForegroundNotification = config["showForegroundNotification"] as? Bool ?? true
+    let entrigConfig = EntrigConfig(apiKey: apiKey, handlePermission: handlePermission, showForegroundNotification: showForegroundNotification)
+
+    // Set up SDK listeners
+    Entrig.setOnForegroundNotificationListener(self)
+    Entrig.setOnNotificationOpenedListener(self)
+
+    Entrig.configure(config: entrigConfig) { success, error in
+      if success {
+        resolver(nil)
+      } else {
+        rejecter("INIT_ERROR", error ?? "Failed to initialize SDK", nil)
+      }
+    }
+  }
+
+  @objc(register:withIsDebug:withResolver:withRejecter:)
+  func register(userId: String, isDebugOverride: NSNumber?, resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    let isDebug: Bool
+    if let override = isDebugOverride {
+      isDebug = override.boolValue
+    } else {
+      #if DEBUG
+      isDebug = true
+      #else
+      isDebug = false
+      #endif
+    }
+
+    Entrig.register(userId: userId, sdk: "react-native", isDebug: isDebug) { success, error in
+      if success {
+        resolver(nil)
+      } else {
+        rejecter("REGISTER_ERROR", error ?? "Registration failed", nil)
+      }
+    }
+  }
+
+  @objc(requestPermission:withRejecter:)
+  func requestPermission(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    Entrig.requestPermission { granted, error in
+      if let error = error {
+        rejecter("PERMISSION_ERROR", error.localizedDescription, nil)
+      } else {
+        resolver(granted)
+      }
+    }
+  }
+
+  @objc(unregister:withRejecter:)
+  func unregister(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    Entrig.unregister { success, error in
+      if success {
+        resolver(nil)
+      } else {
+        rejecter("UNREGISTER_ERROR", error ?? "Unregistration failed", nil)
+      }
+    }
+  }
+
+  @objc(getInitialNotification:withRejecter:)
+  func getInitialNotification(resolver: @escaping RCTPromiseResolveBlock, rejecter: @escaping RCTPromiseRejectBlock) {
+    if let event = Entrig.getInitialNotification() {
+      let payload: [String: Any] = [
+        "title": event.title ?? "",
+        "body": event.body ?? "",
+        "data": event.data ?? [:],
+        "isForeground": false
+      ]
+      resolver(payload)
+    } else {
+      resolver(nil)
+    }
+  }
+
+  // Helper method to send notification events to JavaScript
+  private func sendNotificationToJS(event: NotificationEvent, isForeground: Bool) {
+    guard hasListeners else { return }
+
+    let payload: [String: Any] = [
+      "title": event.title ?? "",
+      "body": event.body ?? "",
+      "data": event.data ?? [:],
+      "isForeground": isForeground
+    ]
+
+    if isForeground {
+      sendEvent(withName: "onForegroundNotification", body: payload)
+    } else {
+      sendEvent(withName: "onNotificationOpened", body: payload)
+    }
+  }
+}
+
+// MARK: - SDK Listeners
+extension EntrigModule: OnNotificationReceivedListener {
+  func onNotificationReceived(_ event: NotificationEvent) {
+    sendNotificationToJS(event: event, isForeground: true)
+  }
+}
+
+extension EntrigModule: OnNotificationClickListener {
+  func onNotificationClick(_ event: NotificationEvent) {
+    sendNotificationToJS(event: event, isForeground: false)
+  }
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@entrig/react-native",
+  "version": "0.0.1",
+  "description": "Entrig | Push Notifications for Supabase",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "bin": {
+    "entrig-react-native": "./bin/setup.js"
+  },
+  "files": [
+    "build/",
+    "ios/",
+    "android/",
+    "plugin/",
+    "bin/",
+    "app.plugin.js",
+    "react-native.config.js",
+    "EntrigReactNative.podspec"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf build/",
+    "lint": "eslint src/ --ext .ts,.tsx",
+    "test": "jest",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "entrig",
+    "push-notifications",
+    "supabase",
+    "notifications",
+    "apns",
+    "fcm"
+  ],
+  "repository": "https://github.com/entrig/entrig-react-native",
+  "bugs": {
+    "url": "https://github.com/entrig/entrig-react-native/issues"
+  },
+  "author": "entrig <team@entrig.com> (https://github.com/entrig)",
+  "license": "MIT",
+  "homepage": "https://github.com/entrig/entrig-react-native#readme",
+  "devDependencies": {
+    "@expo/config-plugins": "^54.0.4",
+    "@types/react": "^19.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@expo/config-plugins": ">=7.0.0",
+    "react": "*",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "@expo/config-plugins": {
+      "optional": true
+    },
+    "expo": {
+      "optional": true
+    }
+  },
+  "expo": {
+    "autolinking": {
+      "nativeModulesDir": "."
+    }
+  }
+}

package/plugin/withEntrig.js

@@ -0,0 +1,298 @@
+const {
+  withInfoPlist,
+  withEntitlementsPlist,
+  withDangerousMod,
+} = require('@expo/config-plugins');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Expo config plugin for Entrig React Native SDK
+ * Automatically configures push notification entitlements, capabilities,
+ * and AppDelegate hooks.
+ *
+ * Add to app.json:
+ * {
+ *   "expo": {
+ *     "plugins": ["@entrig/react-native"]
+ *   }
+ * }
+ */
+function withEntrig(config) {
+  config = withInfoPlist(config, modifyInfoPlist);
+  config = withEntitlementsPlist(config, modifyEntitlementsPlist);
+  config = withDangerousMod(config, ['ios', modifyAppDelegate]);
+  return config;
+}
+
+/**
+ * Add UIBackgroundModes with remote-notification to Info.plist
+ */
+function modifyInfoPlist(config) {
+  const infoPlist = config.modResults;
+
+  if (!infoPlist.UIBackgroundModes) {
+    infoPlist.UIBackgroundModes = [];
+  }
+
+  if (!infoPlist.UIBackgroundModes.includes('remote-notification')) {
+    infoPlist.UIBackgroundModes.push('remote-notification');
+  }
+
+  return config;
+}
+
+/**
+ * Add APS environment to entitlements
+ */
+function modifyEntitlementsPlist(config) {
+  const entitlements = config.modResults;
+
+  if (!entitlements['aps-environment']) {
+    entitlements['aps-environment'] = 'development';
+  }
+
+  return config;
+}
+
+/**
+ * Inject AppDelegate hooks for push notification handling.
+ * Handles both Swift (modern Expo/RN 0.71+) and ObjC AppDelegates.
+ */
+async function modifyAppDelegate(config) {
+  const iosRoot = path.join(config.modRequest.platformProjectRoot);
+
+  // Find the app delegate file
+  const appName = config.modRequest.projectName || config.name;
+  const swiftPath = path.join(iosRoot, appName, 'AppDelegate.swift');
+  const objcPath = path.join(iosRoot, appName, 'AppDelegate.mm');
+
+  if (fs.existsSync(swiftPath)) {
+    patchSwiftAppDelegate(swiftPath);
+  } else if (fs.existsSync(objcPath)) {
+    patchObjCAppDelegate(objcPath);
+  }
+
+  return config;
+}
+
+// ---------------------------------------------------------------------------
+// Swift AppDelegate patching (Expo prebuild generates Swift by default)
+// ---------------------------------------------------------------------------
+
+function patchSwiftAppDelegate(filePath) {
+  let content = fs.readFileSync(filePath, 'utf8');
+
+  // Already configured?
+  if (content.includes('Entrig.checkLaunchNotification') || content.includes('EntrigSDK')) {
+    return;
+  }
+
+  // 1. Add imports
+  if (!content.includes('import UserNotifications')) {
+    const importMatch = content.match(/^import \w+/m);
+    if (importMatch) {
+      content = content.replace(
+        importMatch[0],
+        importMatch[0] + '\nimport UserNotifications'
+      );
+    }
+  }
+
+  if (!content.includes('import EntrigSDK')) {
+    const importMatch = content.match(/^import \w+/m);
+    if (importMatch) {
+      content = content.replace(
+        importMatch[0],
+        importMatch[0] + '\nimport EntrigSDK'
+      );
+    }
+  }
+
+  // 2. Add UNUserNotificationCenterDelegate conformance to the class
+  if (!content.includes('UNUserNotificationCenterDelegate')) {
+    const classPattern = /(class\s+AppDelegate\s*:\s*[^{]+)\{/;
+    const classMatch = content.match(classPattern);
+    if (classMatch) {
+      const declaration = classMatch[1].trimEnd();
+      content = content.replace(
+        classMatch[0],
+        declaration + ', UNUserNotificationCenterDelegate {'
+      );
+    }
+  }
+
+  // 3. Add setup code inside didFinishLaunchingWithOptions
+  if (!content.includes('Entrig.checkLaunchNotification')) {
+    const didFinishPattern =
+      /func application\(\s*_\s+application:\s*UIApplication,\s*didFinishLaunchingWithOptions\s+launchOptions:[^)]*\)\s*->\s*Bool\s*\{/s;
+    const didFinishMatch = content.match(didFinishPattern);
+
+    if (didFinishMatch) {
+      const insertPos = didFinishMatch.index + didFinishMatch[0].length;
+      const setupCode = `
+    // Entrig: Setup push notification handling
+    UNUserNotificationCenter.current().delegate = self
+    Entrig.checkLaunchNotification(launchOptions)
+`;
+      content = content.slice(0, insertPos) + setupCode + content.slice(insertPos);
+    }
+  }
+
+  // 4. Add delegate methods before the closing brace of the AppDelegate class
+  if (!content.includes('didRegisterForRemoteNotificationsWithDeviceToken')) {
+    const delegateMethods = `
+  // MARK: - Entrig Push Notification Handling
+
+  override func application(_ application: UIApplication,
+      didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+    Entrig.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    super.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken)
+  }
+
+  override func application(_ application: UIApplication,
+      didFailToRegisterForRemoteNotificationsWithError error: Error) {
+    Entrig.didFailToRegisterForRemoteNotifications(error: error)
+    super.application(application, didFailToRegisterForRemoteNotificationsWithError: error)
+  }
+
+  func userNotificationCenter(_ center: UNUserNotificationCenter,
+                               willPresent notification: UNNotification,
+                               withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+    Entrig.willPresentNotification(notification)
+    completionHandler(Entrig.getPresentationOptions())
+  }
+
+  func userNotificationCenter(_ center: UNUserNotificationCenter,
+                               didReceive response: UNNotificationResponse,
+                               withCompletionHandler completionHandler: @escaping () -> Void) {
+    Entrig.didReceiveNotification(response)
+    completionHandler()
+  }
+`;
+
+    const lastBrace = findClassClosingBrace(content);
+    if (lastBrace !== -1) {
+      content = content.slice(0, lastBrace) + delegateMethods + content.slice(lastBrace);
+    }
+  }
+
+  fs.writeFileSync(filePath, content);
+}
+
+// ---------------------------------------------------------------------------
+// ObjC AppDelegate patching (older Expo/RN projects)
+// ---------------------------------------------------------------------------
+
+function patchObjCAppDelegate(filePath) {
+  let content = fs.readFileSync(filePath, 'utf8');
+
+  // Already configured?
+  if (content.includes('[Entrig checkLaunchNotification') || content.includes('EntrigSDK')) {
+    return;
+  }
+
+  // 1. Add imports
+  if (!content.includes('UserNotifications/UserNotifications.h')) {
+    content = '#import <UserNotifications/UserNotifications.h>\n' + content;
+  }
+
+  if (!content.includes('@import EntrigSDK')) {
+    content = '@import EntrigSDK;\n' + content;
+  }
+
+  // 2. Add UNUserNotificationCenterDelegate to interface
+  if (!content.includes('UNUserNotificationCenterDelegate')) {
+    const interfacePattern = /(@interface\s+AppDelegate[^>]*>)/;
+    const interfaceMatch = content.match(interfacePattern);
+    if (interfaceMatch) {
+      // Check if there's already a protocol list
+      if (interfaceMatch[0].includes('<')) {
+        // Add to existing protocol list before the closing >
+        content = content.replace(
+          interfaceMatch[0],
+          interfaceMatch[0].replace('>', ', UNUserNotificationCenterDelegate>')
+        );
+      }
+    }
+  }
+
+  // 3. Add setup in didFinishLaunchingWithOptions
+  if (!content.includes('[Entrig checkLaunchNotification')) {
+    const didFinishPattern =
+      /(-\s*\(BOOL\)application:.*?didFinishLaunchingWithOptions:.*?\{)/s;
+    const didFinishMatch = content.match(didFinishPattern);
+
+    if (didFinishMatch) {
+      const insertPos = didFinishMatch.index + didFinishMatch[0].length;
+      const setupCode = `
+  // Entrig: Setup push notification handling
+  [UNUserNotificationCenter currentNotificationCenter].delegate = self;
+  [Entrig checkLaunchNotification:launchOptions];
+`;
+      content = content.slice(0, insertPos) + setupCode + content.slice(insertPos);
+    }
+  }
+
+  // 4. Add delegate methods before @end
+  if (!content.includes('didRegisterForRemoteNotificationsWithDeviceToken')) {
+    const endIdx = content.lastIndexOf('@end');
+    if (endIdx !== -1) {
+      const delegateMethods = `
+// MARK: - Entrig Push Notification Handling
+
+- (void)application:(UIApplication *)application
+    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
+  [Entrig didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+}
+
+- (void)application:(UIApplication *)application
+    didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
+  [Entrig didFailToRegisterForRemoteNotificationsWithError:error];
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
+  [Entrig willPresentNotification:notification];
+  completionHandler([Entrig getPresentationOptions]);
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+    didReceiveNotificationResponse:(UNNotificationResponse *)response
+         withCompletionHandler:(void (^)(void))completionHandler {
+  [Entrig didReceiveNotification:response];
+  completionHandler();
+}
+
+`;
+      content = content.slice(0, endIdx) + delegateMethods + content.slice(endIdx);
+    }
+  }
+
+  fs.writeFileSync(filePath, content);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findClassClosingBrace(content) {
+  const classStart = content.indexOf('class AppDelegate');
+  if (classStart === -1) return -1;
+
+  const openBrace = content.indexOf('{', classStart);
+  if (openBrace === -1) return -1;
+
+  let depth = 1;
+  let i = openBrace + 1;
+  while (i < content.length && depth > 0) {
+    if (content[i] === '{') depth++;
+    else if (content[i] === '}') depth--;
+    if (depth === 0) return i;
+    i++;
+  }
+  return -1;
+}
+
+module.exports = withEntrig;

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {
+        podspecPath: './EntrigReactNative.podspec',
+      },
+      android: {},
+    },
+  },
+};