@sigx/lynx-notifications 0.4.1 → 0.4.2

package/android/com/sigx/notifications/SigxFirebaseMessagingService.kt

@@ -0,0 +1,115 @@
+package com.sigx.notifications
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+
+/**
+ * FCM entry point. Registered in AndroidManifest via the auto-linker
+ * (`android.services` in `signalx-module.json`).
+ *
+ * Handles two callbacks:
+ *   - [onNewToken]: token rotated. Forwarded to JS via [PushEventBus] so the
+ *     app can re-register with its backend (Azure Notification Hubs, etc.).
+ *   - [onMessageReceived]: incoming push. Forwarded to JS regardless of app
+ *     state. When the app is BACKGROUNDED and the payload carries a
+ *     title/body, we additionally pop a system notification so the user has
+ *     a visible entry point back into the app — without this, FCM data-only
+ *     messages received while backgrounded silently land in JS but never
+ *     surface in the system tray. When the app is foreground, we skip the
+ *     system notif: the JS heap is alive and apps are expected to render
+ *     their own in-app UI from `addPushListener`.
+ */
+class SigxFirebaseMessagingService : FirebaseMessagingService() {
+
+    override fun onNewToken(token: String) {
+        super.onNewToken(token)
+        PushEventBus.publishToken(token, platform = "fcm")
+    }
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        super.onMessageReceived(message)
+        val notification = message.notification
+        val title = notification?.title
+        val body = notification?.body
+        val data = message.data
+        // foreground=true here is "the JS heap is alive". FCM service runs
+        // regardless of activity foreground state, but the JS shim and apps
+        // typically treat `foreground` as "received while app was in use" —
+        // we approximate by checking the process importance.
+        val foreground = isAppInForeground()
+        PushEventBus.publishMessage(
+            title = title,
+            body = body,
+            data = data,
+            foreground = foreground,
+        )
+
+        if (!foreground && title != null) {
+            showSystemNotification(title, body ?: "", data)
+        }
+    }
+
+    private fun isAppInForeground(): Boolean {
+        val appProcessInfo = android.app.ActivityManager.RunningAppProcessInfo()
+        android.app.ActivityManager.getMyMemoryState(appProcessInfo)
+        return appProcessInfo.importance == android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND ||
+            appProcessInfo.importance == android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE
+    }
+
+    private fun showSystemNotification(title: String, body: String, data: Map<String, String>) {
+        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        // The FCM service can fire BEFORE NotificationsModule is ever
+        // instantiated (the JS bridge may not have loaded yet — particularly
+        // for data-only messages that wake the app from a fully terminated
+        // state). Ensure the notification channel exists here too so
+        // `notify()` on O+ doesn't silently drop the post.
+        ensureChannel(manager)
+        // Prefer the app's launcher icon over the stock dialog icon — Android
+        // renders small-icons as monochrome silhouettes, so a generic system
+        // shape would show up as a plain square. `applicationInfo.icon` is
+        // the manifest <application android:icon>, which apps always set.
+        val smallIcon = applicationInfo.icon.takeIf { it != 0 } ?: android.R.drawable.ic_dialog_info
+        val builder = NotificationCompat.Builder(this, NotificationsModule.CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setSmallIcon(smallIcon)
+            .setAutoCancel(true)
+
+        // Stash data on the launch intent so [PushActivityHook.onNewIntent]
+        // can route the tap to [PushEventBus.publishResponse] / capture as
+        // the cold-start payload.
+        val pm = packageManager
+        val launchIntent = pm.getLaunchIntentForPackage(packageName)?.apply {
+            putExtra(PushActivityHook.EXTRA_NOTIFICATION_TAP, true)
+            for ((k, v) in data) putExtra("sigx_push_data_$k", v)
+        }
+        val notificationId = (data["notification_id"] ?: data["notificationId"] ?: System.currentTimeMillis().toString())
+        if (launchIntent != null) {
+            val pending = android.app.PendingIntent.getActivity(
+                this,
+                notificationId.hashCode(),
+                launchIntent,
+                android.app.PendingIntent.FLAG_UPDATE_CURRENT or android.app.PendingIntent.FLAG_IMMUTABLE,
+            )
+            builder.setContentIntent(pending)
+        }
+
+        manager.notify(notificationId.hashCode(), builder.build())
+    }
+
+    private fun ensureChannel(manager: NotificationManager) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        if (manager.getNotificationChannel(NotificationsModule.CHANNEL_ID) != null) return
+        val channel = NotificationChannel(
+            NotificationsModule.CHANNEL_ID,
+            "sigx-lynx-go",
+            NotificationManager.IMPORTANCE_DEFAULT,
+        )
+        manager.createNotificationChannel(channel)
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { Notifications } from './notifications.js';
-export type { NotificationContent, ScheduleOptions } from './notifications.js';
+export type { NotificationContent, ScheduleOptions, RegisterPushResult, UnregisterPushResult, NotificationResponse, PushTokenEvent, PushTokenError, RemoteMessage, } from './notifications.js';
+export { addTokenListener, addTokenErrorListener, addPushListener, addNotificationResponseListener, } from './push.js';
 export type { PermissionResponse } from '@sigx/lynx-core';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACR,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,aAAa,GAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,+BAA+B,GAClC,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export { Notifications } from './notifications.js';
+export { addTokenListener, addTokenErrorListener, addPushListener, addNotificationResponseListener, } from './push.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAWnD,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,+BAA+B,GAClC,MAAM,WAAW,CAAC"}

package/dist/notifications.d.ts

@@ -1,8 +1,9 @@
 import type { PermissionResponse } from '@sigx/lynx-core';
+import { addTokenListener, addTokenErrorListener, addPushListener, addNotificationResponseListener, type NotificationResponse, type PushTokenEvent, type PushTokenError, type RemoteMessage } from './push.js';
 export interface NotificationContent {
     title: string;
     body: string;
-    /** Optional data payload */
+    /** Optional data payload. Round-tripped to JS on tap responses. */
     data?: Record<string, string>;
 }
 export interface ScheduleOptions {
@@ -11,27 +12,100 @@ export interface ScheduleOptions {
     /** Repeat interval: 'minute', 'hour', 'day', 'week' */
     repeat?: 'minute' | 'hour' | 'day' | 'week';
 }
+export interface RegisterPushResult {
+    token?: string;
+    platform?: 'apns' | 'fcm';
+    /** iOS resolves with `{ dispatched: true }` — the real token arrives via `addTokenListener`. */
+    dispatched?: boolean;
+    error?: string;
+}
+export interface UnregisterPushResult {
+    ok: boolean;
+    error?: string;
+}
 /**
- * Local notification APIs.
+ * Local + remote notification APIs.
  *
  * @example
  * ```ts
  * import { Notifications } from '@sigx/lynx-notifications';
  *
  * const { status } = await Notifications.requestPermission();
- * if (status === 'granted') {
- *     await Notifications.schedule({ title: 'Reminder', body: 'Check your tasks' }, { delay: 60 });
- * }
+ * if (status !== 'granted') return;
+ *
+ * // Remote push registration. On iOS the real token arrives via addTokenListener;
+ * // on Android the token is in the promise result.
+ * Notifications.addTokenListener(({ token, platform }) => {
+ *     // POST token + platform to your backend (Azure Notification Hubs / Firebase Admin / …)
+ * });
+ * Notifications.addPushListener((msg) => {
+ *     console.log('push received', msg);
+ * });
+ * Notifications.addNotificationResponseListener((resp) => {
+ *     // user tapped the notification — route them somewhere
+ * });
+ *
+ * await Notifications.registerForPushNotifications();
+ *
+ * // Cold-start tap (if any)
+ * const initial = await Notifications.getInitialNotification();
  * ```
  */
 export declare const Notifications: {
-    schedule(content: NotificationContent, options?: ScheduleOptions): Promise<string>;
-    cancel(notificationId: string): Promise<void>;
-    cancelAll(): Promise<void>;
+    readonly schedule: (content: NotificationContent, options?: ScheduleOptions) => Promise<string>;
+    readonly cancel: (notificationId: string) => Promise<void>;
+    readonly cancelAll: () => Promise<void>;
     /** Request notification permission, showing the OS dialog if needed. */
-    requestPermission(): Promise<PermissionResponse>;
+    readonly requestPermission: () => Promise<PermissionResponse>;
     /** Check current notification permission status without prompting. */
-    getPermissionStatus(): Promise<PermissionResponse>;
-    isAvailable(): boolean;
+    readonly getPermissionStatus: () => Promise<PermissionResponse>;
+    /**
+     * Trigger remote-push registration.
+     *
+     * iOS: dispatches `application.registerForRemoteNotifications()`. The
+     * token (or error) arrives asynchronously via `addTokenListener` /
+     * `addTokenErrorListener`. The promise resolves with `{ dispatched: true }`
+     * once the call has been made.
+     *
+     * Android: resolves directly with the FCM token. Also publishes the token
+     * via the listener channel so JS code that wires both paths sees one
+     * canonical event.
+     */
+    readonly registerForPushNotifications: () => Promise<RegisterPushResult>;
+    /**
+     * Detach from APNs / FCM.
+     *
+     * iOS: synchronous — resolves with `{ ok: true }` after
+     * `unregisterForRemoteNotifications` is called.
+     * Android: awaits the FCM `deleteToken()` Task; resolves with
+     * `{ ok: false, error }` if the network call fails so the JS caller
+     * doesn't believe it's unregistered while the server keeps pushing.
+     * Failures also publish on the `addTokenErrorListener` channel.
+     */
+    readonly unregisterForPushNotifications: () => Promise<UnregisterPushResult>;
+    /**
+     * iOS: app-icon badge count. iOS 16+ uses
+     * `UNUserNotificationCenter.setBadgeCount`; older falls back to
+     * `applicationIconBadgeNumber`.
+     *
+     * Android: no-op. Stock Android has no portable badging API (it's
+     * vendor-specific — Samsung's `ShortcutBadger`, etc.) and this call
+     * does NOT clear pending notifications — callers wanting that should
+     * use `cancelAll()` directly.
+     */
+    readonly setBadgeCount: (count: number) => Promise<void>;
+    /** iOS: current badge number. Android: always 0 (no portable read API). */
+    readonly getBadgeCount: () => Promise<number>;
+    /**
+     * If the app was launched by a notification tap, returns the payload.
+     * One-shot: subsequent calls return null. Call exactly once during startup.
+     */
+    readonly getInitialNotification: () => Promise<NotificationResponse | null>;
+    readonly addTokenListener: typeof addTokenListener;
+    readonly addTokenErrorListener: typeof addTokenErrorListener;
+    readonly addPushListener: typeof addPushListener;
+    readonly addNotificationResponseListener: typeof addNotificationResponseListener;
+    readonly isAvailable: () => boolean;
 };
+export type { NotificationResponse, PushTokenEvent, PushTokenError, RemoteMessage };
 //# sourceMappingURL=notifications.d.ts.map

package/dist/notifications.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../src/notifications.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAI1D,MAAM,WAAW,mBAAmB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC5B,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;CAC/C;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa;IACtB,QAAQ,UAAU,mBAAmB,YAAW,eAAe,GAAQ,OAAO,CAAC,MAAM,CAAC;IAItF,MAAM,iBAAiB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1B,wEAAwE;IACxE,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIhD,sEAAsE;IACtE,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAIlD,WAAW,IAAI,OAAO;CAGhB,CAAC"}
+{"version":3,"file":"notifications.d.ts","sourceRoot":"","sources":["../src/notifications.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,+BAA+B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EACrB,MAAM,WAAW,CAAC;AAInB,MAAM,WAAW,mBAAmB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC5B,gCAAgC;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;CAC/C;AAED,MAAM,WAAW,kBAAkB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC1B,gGAAgG;IAChG,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACjC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa;iCACJ,mBAAmB,YAAW,eAAe,KAAQ,OAAO,CAAC,MAAM,CAAC;sCAI/D,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;8BAIhC,OAAO,CAAC,IAAI,CAAC;IAI1B,wEAAwE;sCACnD,OAAO,CAAC,kBAAkB,CAAC;IAIhD,sEAAsE;wCAC/C,OAAO,CAAC,kBAAkB,CAAC;IAIlD;;;;;;;;;;;OAWG;iDAC6B,OAAO,CAAC,kBAAkB,CAAC;IAI3D;;;;;;;;;OASG;mDAC+B,OAAO,CAAC,oBAAoB,CAAC;IAI/D;;;;;;;;;OASG;oCACkB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,2EAA2E;kCAC1D,OAAO,CAAC,MAAM,CAAC;IAIhC;;;OAGG;2CACuB,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;;;;;gCAa/C,OAAO;CAGhB,CAAC;AAEX,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC"}

package/dist/notifications.js

@@ -1,16 +1,32 @@
 import { callAsync, isModuleAvailable } from '@sigx/lynx-core';
+import { addTokenListener, addTokenErrorListener, addPushListener, addNotificationResponseListener, } from './push.js';
 const MODULE = 'Notifications';
 /**
- * Local notification APIs.
+ * Local + remote notification APIs.
  *
  * @example
  * ```ts
  * import { Notifications } from '@sigx/lynx-notifications';
  *
  * const { status } = await Notifications.requestPermission();
- * if (status === 'granted') {
- *     await Notifications.schedule({ title: 'Reminder', body: 'Check your tasks' }, { delay: 60 });
- * }
+ * if (status !== 'granted') return;
+ *
+ * // Remote push registration. On iOS the real token arrives via addTokenListener;
+ * // on Android the token is in the promise result.
+ * Notifications.addTokenListener(({ token, platform }) => {
+ *     // POST token + platform to your backend (Azure Notification Hubs / Firebase Admin / …)
+ * });
+ * Notifications.addPushListener((msg) => {
+ *     console.log('push received', msg);
+ * });
+ * Notifications.addNotificationResponseListener((resp) => {
+ *     // user tapped the notification — route them somewhere
+ * });
+ *
+ * await Notifications.registerForPushNotifications();
+ *
+ * // Cold-start tap (if any)
+ * const initial = await Notifications.getInitialNotification();
  * ```
  */
 export const Notifications = {
@@ -31,8 +47,68 @@ export const Notifications = {
     getPermissionStatus() {
         return callAsync(MODULE, 'getPermissionStatus');
     },
+    /**
+     * Trigger remote-push registration.
+     *
+     * iOS: dispatches `application.registerForRemoteNotifications()`. The
+     * token (or error) arrives asynchronously via `addTokenListener` /
+     * `addTokenErrorListener`. The promise resolves with `{ dispatched: true }`
+     * once the call has been made.
+     *
+     * Android: resolves directly with the FCM token. Also publishes the token
+     * via the listener channel so JS code that wires both paths sees one
+     * canonical event.
+     */
+    registerForPushNotifications() {
+        return callAsync(MODULE, 'registerForPushNotifications');
+    },
+    /**
+     * Detach from APNs / FCM.
+     *
+     * iOS: synchronous — resolves with `{ ok: true }` after
+     * `unregisterForRemoteNotifications` is called.
+     * Android: awaits the FCM `deleteToken()` Task; resolves with
+     * `{ ok: false, error }` if the network call fails so the JS caller
+     * doesn't believe it's unregistered while the server keeps pushing.
+     * Failures also publish on the `addTokenErrorListener` channel.
+     */
+    unregisterForPushNotifications() {
+        return callAsync(MODULE, 'unregisterForPushNotifications');
+    },
+    /**
+     * iOS: app-icon badge count. iOS 16+ uses
+     * `UNUserNotificationCenter.setBadgeCount`; older falls back to
+     * `applicationIconBadgeNumber`.
+     *
+     * Android: no-op. Stock Android has no portable badging API (it's
+     * vendor-specific — Samsung's `ShortcutBadger`, etc.) and this call
+     * does NOT clear pending notifications — callers wanting that should
+     * use `cancelAll()` directly.
+     */
+    setBadgeCount(count) {
+        return callAsync(MODULE, 'setBadgeCount', count);
+    },
+    /** iOS: current badge number. Android: always 0 (no portable read API). */
+    getBadgeCount() {
+        return callAsync(MODULE, 'getBadgeCount');
+    },
+    /**
+     * If the app was launched by a notification tap, returns the payload.
+     * One-shot: subsequent calls return null. Call exactly once during startup.
+     */
+    getInitialNotification() {
+        return callAsync(MODULE, 'getInitialNotification');
+    },
+    // ── Event subscriptions ─────────────────────────────────────────────────
+    // Re-exported so consumers can chain `Notifications.addTokenListener(...)`
+    // without a second import. Each returns an unsubscribe function.
+    addTokenListener,
+    addTokenErrorListener,
+    addPushListener,
+    addNotificationResponseListener,
     isAvailable() {
         return isModuleAvailable(MODULE);
     },
 };
+// `UnregisterPushResult` is declared above; re-export via index.ts.
 //# sourceMappingURL=notifications.js.map

package/dist/notifications.js.map

@@ -1 +1 @@
-{"version":3,"file":"notifications.js","sourceRoot":"","sources":["../src/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,MAAM,MAAM,GAAG,eAAe,CAAC;AAgB/B;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,QAAQ,CAAC,OAA4B,EAAE,OAAO,GAAoB,EAAE;QAChE,OAAO,SAAS,CAAS,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,CAAC,cAAsB;QACzB,OAAO,SAAS,CAAO,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;IAC7D,CAAC;IAED,SAAS;QACL,OAAO,SAAS,CAAO,MAAM,EAAE,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,wEAAwE;IACxE,iBAAiB;QACb,OAAO,SAAS,CAAqB,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IAED,sEAAsE;IACtE,mBAAmB;QACf,OAAO,SAAS,CAAqB,MAAM,EAAE,qBAAqB,CAAC,CAAC;IACxE,CAAC;IAED,WAAW;QACP,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACK,CAAC"}
+{"version":3,"file":"notifications.js","sourceRoot":"","sources":["../src/notifications.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE/D,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,eAAe,EACf,+BAA+B,GAKlC,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,GAAG,eAAe,CAAC;AA6B/B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,QAAQ,CAAC,OAA4B,EAAE,OAAO,GAAoB,EAAE;QAChE,OAAO,SAAS,CAAS,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,CAAC,cAAsB;QACzB,OAAO,SAAS,CAAO,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAC;IAC7D,CAAC;IAED,SAAS;QACL,OAAO,SAAS,CAAO,MAAM,EAAE,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,wEAAwE;IACxE,iBAAiB;QACb,OAAO,SAAS,CAAqB,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IAED,sEAAsE;IACtE,mBAAmB;QACf,OAAO,SAAS,CAAqB,MAAM,EAAE,qBAAqB,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,4BAA4B;QACxB,OAAO,SAAS,CAAqB,MAAM,EAAE,8BAA8B,CAAC,CAAC;IACjF,CAAC;IAED;;;;;;;;;OASG;IACH,8BAA8B;QAC1B,OAAO,SAAS,CAAuB,MAAM,EAAE,gCAAgC,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;;;;OASG;IACH,aAAa,CAAC,KAAa;QACvB,OAAO,SAAS,CAAO,MAAM,EAAE,eAAe,EAAE,KAAK,CAAC,CAAC;IAC3D,CAAC;IAED,2EAA2E;IAC3E,aAAa;QACT,OAAO,SAAS,CAAS,MAAM,EAAE,eAAe,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,sBAAsB;QAClB,OAAO,SAAS,CAA8B,MAAM,EAAE,wBAAwB,CAAC,CAAC;IACpF,CAAC;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,iEAAiE;IAEjE,gBAAgB;IAChB,qBAAqB;IACrB,eAAe;IACf,+BAA+B;IAE/B,WAAW;QACP,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACK,CAAC;AAGX,oEAAoE"}

package/dist/push.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Remote-push event subscriptions. Backed by `GlobalEventEmitter` on four
+ * native channels: `__sigxPushToken`, `__sigxPushTokenError`,
+ * `__sigxPushMessage`, `__sigxNotificationResponse`. The native side carries
+ * the same channel names — JS shims here just adapt the listener-bag API.
+ */
+export interface PushTokenEvent {
+    token: string;
+    platform: 'apns' | 'fcm';
+}
+export interface PushTokenError {
+    error: string;
+}
+export interface RemoteMessage {
+    title?: string;
+    body?: string;
+    data: Record<string, string>;
+    foreground: boolean;
+}
+export interface NotificationResponse {
+    notificationId: string;
+    data: Record<string, string>;
+    /** 'default' for the standard tap; custom action ids when categories ship. */
+    actionIdentifier: string;
+}
+export declare function addTokenListener(cb: (event: PushTokenEvent) => void): () => void;
+export declare function addTokenErrorListener(cb: (event: PushTokenError) => void): () => void;
+export declare function addPushListener(cb: (event: RemoteMessage) => void): () => void;
+export declare function addNotificationResponseListener(cb: (event: NotificationResponse) => void): () => void;
+//# sourceMappingURL=push.d.ts.map

package/dist/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,oBAAoB;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AA+CD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,MAAM,IAAI,CAEhF;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,MAAM,IAAI,CAErF;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI,CAE9E;AAED,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,GAAG,MAAM,IAAI,CAErG"}

package/dist/push.js

@@ -0,0 +1,59 @@
+/**
+ * Remote-push event subscriptions. Backed by `GlobalEventEmitter` on four
+ * native channels: `__sigxPushToken`, `__sigxPushTokenError`,
+ * `__sigxPushMessage`, `__sigxNotificationResponse`. The native side carries
+ * the same channel names — JS shims here just adapt the listener-bag API.
+ */
+const TOKEN_CHANNEL = '__sigxPushToken';
+const TOKEN_ERROR_CHANNEL = '__sigxPushTokenError';
+const MESSAGE_CHANNEL = '__sigxPushMessage';
+const RESPONSE_CHANNEL = '__sigxNotificationResponse';
+function emitter() {
+    if (typeof lynx === 'undefined')
+        return undefined;
+    const obj = lynx;
+    return obj.getJSModule?.('GlobalEventEmitter');
+}
+function subscribe(channel, cb) {
+    const e = emitter();
+    if (!e) {
+        // Web / SSR / test fallback: no native bridge, just return a no-op
+        // unsubscribe. The shim is a one-way data path — there's nothing
+        // useful to emulate.
+        return () => { };
+    }
+    const wrapped = (raw) => {
+        const event = (typeof raw === 'string' ? safeParse(raw) : raw);
+        if (event === undefined)
+            return;
+        try {
+            cb(event);
+        }
+        catch (err) {
+            console.warn(`[notifications] listener for ${channel} threw:`, err);
+        }
+    };
+    e.addListener(channel, wrapped);
+    return () => e.removeListener(channel, wrapped);
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function addTokenListener(cb) {
+    return subscribe(TOKEN_CHANNEL, cb);
+}
+export function addTokenErrorListener(cb) {
+    return subscribe(TOKEN_ERROR_CHANNEL, cb);
+}
+export function addPushListener(cb) {
+    return subscribe(MESSAGE_CHANNEL, cb);
+}
+export function addNotificationResponseListener(cb) {
+    return subscribe(RESPONSE_CHANNEL, cb);
+}
+//# sourceMappingURL=push.js.map

package/dist/push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.js","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,aAAa,GAAG,iBAAiB,CAAC;AACxC,MAAM,mBAAmB,GAAG,sBAAsB,CAAC;AACnD,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAC5C,MAAM,gBAAgB,GAAG,4BAA4B,CAAC;AAoCtD,SAAS,OAAO;IACZ,IAAI,OAAO,IAAI,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IAClD,MAAM,GAAG,GAAG,IAA2B,CAAC;IACxC,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC,oBAAoB,CAAC,CAAC;AACnD,CAAC;AAED,SAAS,SAAS,CACd,OAAe,EACf,EAAsB;IAEtB,MAAM,CAAC,GAAG,OAAO,EAAE,CAAC;IACpB,IAAI,CAAC,CAAC,EAAE,CAAC;QACL,mEAAmE;QACnE,iEAAiE;QACjE,qBAAqB;QACrB,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;IACpB,CAAC;IACD,MAAM,OAAO,GAAG,CAAC,GAAY,EAAE,EAAE;QAC7B,MAAM,KAAK,GAAG,CAAC,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAkB,CAAC;QAChF,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO;QAChC,IAAI,CAAC;YACD,EAAE,CAAC,KAAK,CAAC,CAAC;QACd,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,gCAAgC,OAAO,SAAS,EAAE,GAAG,CAAC,CAAC;QACxE,CAAC;IACL,CAAC,CAAC;IACF,CAAC,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,GAAG,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AACpD,CAAC;AAED,SAAS,SAAS,CAAC,CAAS;IACxB,IAAI,CAAC;QAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,SAAS,CAAC;IAAC,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,EAAmC;IAChE,OAAO,SAAS,CAAiB,aAAa,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,EAAmC;IACrE,OAAO,SAAS,CAAiB,mBAAmB,EAAE,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,EAAkC;IAC9D,OAAO,SAAS,CAAgB,eAAe,EAAE,EAAE,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,EAAyC;IACrF,OAAO,SAAS,CAAuB,gBAAgB,EAAE,EAAE,CAAC,CAAC;AACjE,CAAC"}

package/ios/NotificationsModule.swift

@@ -1,9 +1,10 @@
 import Foundation
+import UIKit
 import UserNotifications
 import Lynx
 
-/// Local notifications module.
-/// JS usage: NativeModules.Notifications.schedule({ title, body }, { delay }, callback)
+/// Local + remote notifications module.
+/// JS usage: NativeModules.Notifications.<method>(...)
 class NotificationsModule: NSObject, LynxModule {
 
     @objc static var name: String { "Notifications" }
@@ -15,6 +16,11 @@ class NotificationsModule: NSObject, LynxModule {
             "cancelAll": NSStringFromSelector(#selector(cancelAll(_:))),
             "requestPermission": NSStringFromSelector(#selector(requestPermission(_:))),
             "getPermissionStatus": NSStringFromSelector(#selector(getPermissionStatus(_:))),
+            "registerForPushNotifications": NSStringFromSelector(#selector(registerForPushNotifications(_:))),
+            "unregisterForPushNotifications": NSStringFromSelector(#selector(unregisterForPushNotifications(_:))),
+            "setBadgeCount": NSStringFromSelector(#selector(setBadgeCount(_:callback:))),
+            "getBadgeCount": NSStringFromSelector(#selector(getBadgeCount(_:))),
+            "getInitialNotification": NSStringFromSelector(#selector(getInitialNotification(_:))),
         ]
     }
 
@@ -25,6 +31,7 @@ class NotificationsModule: NSObject, LynxModule {
         let title = content?["title"] as? String ?? "Notification"
         let body = content?["body"] as? String ?? ""
         let delay = options?["delay"] as? TimeInterval ?? 0
+        let data = content?["data"] as? [String: String] ?? [:]
 
         let notificationId = UUID().uuidString
 
@@ -32,6 +39,9 @@ class NotificationsModule: NSObject, LynxModule {
         notificationContent.title = title
         notificationContent.body = body
         notificationContent.sound = .default
+        // Round-trip the data dict so a local tap surfaces it on
+        // didReceiveResponse → publishResponse — same wire shape as remote.
+        notificationContent.userInfo = data
 
         let trigger: UNNotificationTrigger
         if delay > 0 {
@@ -91,4 +101,60 @@ class NotificationsModule: NSObject, LynxModule {
             callback?(["status": status])
         }
     }
+
+    // MARK: - Remote push
+
+    /// Ask iOS to contact APNs. The token (or registration failure) arrives
+    /// asynchronously via the AppDelegate hook → `PushEventBus` → JS event.
+    /// The callback only confirms that `registerForRemoteNotifications` was
+    /// dispatched — it does NOT block on token receipt.
+    @objc func registerForPushNotifications(_ callback: LynxCallbackBlock?) {
+        DispatchQueue.main.async {
+            UIApplication.shared.registerForRemoteNotifications()
+            callback?(["dispatched": true])
+        }
+    }
+
+    @objc func unregisterForPushNotifications(_ callback: LynxCallbackBlock?) {
+        DispatchQueue.main.async {
+            UIApplication.shared.unregisterForRemoteNotifications()
+            callback?(["ok": true])
+        }
+    }
+
+    @objc func setBadgeCount(_ count: NSNumber?, callback: LynxCallbackBlock?) {
+        let value = count?.intValue ?? 0
+        if #available(iOS 16.0, *) {
+            UNUserNotificationCenter.current().setBadgeCount(value) { error in
+                if let error = error {
+                    callback?(["error": error.localizedDescription])
+                } else {
+                    callback?(true)
+                }
+            }
+        } else {
+            DispatchQueue.main.async {
+                UIApplication.shared.applicationIconBadgeNumber = value
+                callback?(true)
+            }
+        }
+    }
+
+    @objc func getBadgeCount(_ callback: LynxCallbackBlock?) {
+        DispatchQueue.main.async {
+            callback?(NSNumber(value: UIApplication.shared.applicationIconBadgeNumber))
+        }
+    }
+
+    /// One-shot: return the payload that launched the app from a cold start,
+    /// or nil. Subsequent calls return nil even if the original payload was
+    /// non-nil — JS code that wants to react to launch payloads should call
+    /// this exactly once during startup.
+    @objc func getInitialNotification(_ callback: LynxCallbackBlock?) {
+        if let payload = PushEventBus.shared.consumeInitialResponse() {
+            callback?(payload)
+        } else {
+            callback?(NSNull())
+        }
+    }
 }