@symbiote-native/notifications 0.1.2 → 0.1.3

package/README.md

@@ -1,18 +1,18 @@
 # @symbiote-native/notifications
 
-A wrapper package for [SymbioteNative](../../README.md) that makes
-[`expo-notifications`](https://github.com/expo/expo/tree/main/packages/expo-notifications) —
-permissions, device/Expo push tokens, scheduling, presentation, badges, Android channels, iOS/
-Android categories, and the background notification task hook — usable from **every** adapter:
-React, Vue, Svelte, Solid, and Angular. Built the same way as
+Remind the user at the right moment, reach them with push when the app is closed, and know which
+notification they tapped. One API for every [SymbioteNative](../../README.md) adapter (React, Vue,
+Svelte, Solid and Angular).
+
+It wraps [`expo-notifications`](https://github.com/expo/expo/tree/main/packages/expo-notifications):
+permissions, device and Expo push tokens, scheduling, presentation, badges, Android channels, iOS
+and Android categories, and the background notification task hook. Built the same way as
 [`@symbiote-native/local-auth`](../local-auth): an `expo-modules-core`-based wrapper (see the
-`symbiote-expo-native-module` project skill for the full mechanism — why `expo-modules-core` is
-depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
-`core/` rather than imported, and how autolinking picks up the native module).
+`symbiote-expo-native-module` project skill for the full mechanism).
 
-Every export is a plain async function or a module-level listener registration — no hook/
-composable/service to wrap, so the React, Vue, Svelte, Solid, and Angular entry points are plain
-re-exports of the same `core`.
+Every core export is a plain async function or a module-level listener registration. One
+adapter-specific hook - `useLastNotificationResponse` - is ported to all five adapters (originally
+dropped as React-only; since reversed, see "Push-token resync and defaults" below).
 
 ## Install
 
@@ -29,24 +29,24 @@ npx @symbiote-native/cli add --notifications
 ```
 
 Either way: installs `@symbiote-native/notifications` and wires the native autolinking
-automatically — see [`@symbiote-native/cli`](../cli). Read [past the wiring
+automatically - see [`@symbiote-native/cli`](../cli). Read [past the wiring
 table](#required-one-time-steps-this-linker-does-not-cover--read-before-shipping-push) before
-shipping push, though — the CLI can't automate app-specific native config like a Firebase
+shipping push, though - the CLI can't automate app-specific native config like a Firebase
 project.
 
 <details>
-<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
 
 ```bash
 npm install @symbiote-native/notifications
 ```
 
-`expo-notifications` and `expo-modules-core` come along as regular, pinned dependencies — never
+`expo-notifications` and `expo-modules-core` come along as regular, pinned dependencies - never
 install either yourself, and never add the `expo` meta-package to your project.
 
 ### Required one-time step: native autolinking wiring
 
-Same one-time step as every other `expo-modules-core` package this project ships — see
+Same one-time step as every other `expo-modules-core` package this project ships - see
 [`@symbiote-native/local-auth`'s README](../local-auth/README.md#required-one-time-step-native-autolinking-wiring)
 and the `symbiote-expo-native-module` project skill. The per-package half of that table (the
 Gradle dependency and 13 native-module map entries) is generated by
@@ -55,28 +55,28 @@ on every install.
 
 </details>
 
-### Required one-time steps this linker does NOT cover — read before shipping push
+### Required one-time steps this linker does NOT cover - read before shipping push
 
 Unlike every package this project has wrapped before it, `expo-notifications` needs real,
 app-specific native configuration that a thin JS wrapper cannot supply on its own. Read upstream's
 own config plugin (`plugin/src/withNotifications{Android,IOS}.ts`) before assuming any of this is
-optional — none of it is generated by `@symbiote-native/expo-modules-link`, because none of it fits
+optional - none of it is generated by `@symbiote-native/expo-modules-link`, because none of it fits
 that linker's "fixed value, same for every app" contract (§9 of the `symbiote-expo-native-module`
 skill):
 
 | Platform | What you must add yourself                                                                                                                                                                                                                                                               | Why                                                                                                                                                                                                                                                                                                       |
 | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Android  | A real Firebase project + `google-services.json`, plus the Google Services Gradle plugin                                                                                                                                                                                                 | `android/build.gradle` inside `expo-notifications` depends directly on `com.google.firebase:firebase-messaging` — push delivery is FCM, not a generic APNs-style relay, and this is a real exception to "expo-modules-core only" (see the `symbiote-expo-native-module` skill §10d)                       |
+| Android  | A real Firebase project + `google-services.json`, plus the Google Services Gradle plugin                                                                                                                                                                                                 | `android/build.gradle` inside `expo-notifications` depends directly on `com.google.firebase:firebase-messaging` - push delivery is FCM, not a generic APNs-style relay, and this is a real exception to "expo-modules-core only" (see the `symbiote-expo-native-module` skill §10d)                       |
 | Android  | A 96×96 all-white PNG copied into `res/drawable-*dpi/notification_icon.png`, plus two `<meta-data>` entries on `<application>`: `com.google.firebase.messaging.default_notification_icon` and `expo.modules.notifications.default_notification_icon`, both `@drawable/notification_icon` | The status-bar icon Android draws for a notification your app did not explicitly build with a custom small icon                                                                                                                                                                                           |
 | Android  | Optionally, `android:color` via `@color/notification_icon_color` and the two matching `default_notification_color` meta-data entries                                                                                                                                                     | Tint applied to the small icon above                                                                                                                                                                                                                                                                      |
 | Android  | Optionally, `com.google.firebase.messaging.default_notification_channel_id` meta-data                                                                                                                                                                                                    | Which channel an FCM-delivered notification lands in when the payload does not name one                                                                                                                                                                                                                   |
-| Android  | Copy any custom sound file into `res/raw/`                                                                                                                                                                                                                                               | `INotificationContentInput.sound` accepts a custom filename on iOS; Android channels carry their own `sound` field instead — see `setNotificationChannelAsync`                                                                                                                                            |
-| iOS      | The **Push Notifications** capability + `aps-environment` entitlement (`development` or `production`) in Xcode                                                                                                                                                                           | `getDevicePushTokenAsync`/`getExpoPushTokenAsync` need APNs registration, which needs this entitlement present — omitting it is a silent registration failure, not a thrown error                                                                                                                         |
+| Android  | Copy any custom sound file into `res/raw/`                                                                                                                                                                                                                                               | `INotificationContentInput.sound` accepts a custom filename on iOS; Android channels carry their own `sound` field instead - see `setNotificationChannelAsync`                                                                                                                                            |
+| iOS      | The **Push Notifications** capability + `aps-environment` entitlement (`development` or `production`) in Xcode                                                                                                                                                                           | `getDevicePushTokenAsync`/`getExpoPushTokenAsync` need APNs registration, which needs this entitlement present - omitting it is a silent registration failure, not a thrown error                                                                                                                         |
 | iOS      | Add any custom sound file as a bundle resource in Xcode                                                                                                                                                                                                                                  | Same as Android's `res/raw/` step, for `INotificationContentInput.sound`                                                                                                                                                                                                                                  |
 | iOS      | Optionally, `UIBackgroundModes` including `remote-notification` in `Info.plist`                                                                                                                                                                                                          | Lets a background/silent push wake the app to run a task registered via `registerTaskAsync`                                                                                                                                                                                                               |
-| Both     | [`@symbiote-native/task-manager`](../task-manager) installed, with a task `defineTask`'d at module scope before `registerTaskAsync` runs                                                                                                                                                 | `registerTaskAsync`/`unregisterTaskAsync` here are thin wrappers over expo-notifications' own `BackgroundNotificationTasksModule`, which upstream itself only works when `expo-task-manager` (this project: `@symbiote-native/task-manager`) is linked — see the `symbiote-expo-native-module` skill §10d |
+| Both     | [`@symbiote-native/task-manager`](../task-manager) installed, with a task `defineTask`'d at module scope before `registerTaskAsync` runs                                                                                                                                                 | `registerTaskAsync`/`unregisterTaskAsync` here are thin wrappers over expo-notifications' own `BackgroundNotificationTasksModule`, which upstream itself only works when `expo-task-manager` (this project: `@symbiote-native/task-manager`) is linked - see the `symbiote-expo-native-module` skill §10d |
 
-None of the above is required just to schedule and present **local** notifications — permissions,
+None of the above is required just to schedule and present **local** notifications - permissions,
 scheduling, presentation, badges, channels, and categories all work with zero app-level native
 config beyond the linker step. Firebase, the icon/color meta-data, and the entitlement are only
 needed once you send a **remote/push** notification.
@@ -90,12 +90,19 @@ src/core/                 permissions.ts, tokens.ts, presenter.ts, badge.ts, sch
                           types.ts (I-prefixed, ported from upstream's Notifications.types.ts /
                           Tokens.types.ts / NotificationChannel(Group)Manager.types.ts /
                           NotificationScheduler.types.ts)
-src/angular/index.ts      export * from '../core'
+src/core/last-notification-response.ts  determineNextResponse - the dedup rule every adapter's
+                          useLastNotificationResponse shares
+src/react/hooks/use-last-notification-response/
+src/vue/composables/use-last-notification-response/
+src/solid/primitives/create-last-notification-response.ts
+src/svelte/use-last-notification-response.svelte.ts
+src/angular/services/last-notification-response.service/   LastNotificationResponseService,
+                          connect(): Signal<IMaybeNotificationResponse>
 ```
 
-`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto `src/core/`.
-`./angular` stays a physical file/subpath since Angular ships through a separate `ngc`/AOT build
-(`build-ngc/`).
+Every adapter barrel (`src/{react,vue,solid,svelte}/index.ts`, `src/angular/index.ts`) re-exports
+`../core` plus its own `useLastNotificationResponse`/`createLastNotificationResponse`/
+`LastNotificationResponseService`.
 
 ## Use it
 
@@ -132,7 +139,7 @@ if (granted) {
 }
 ```
 
-Identical import surface on every adapter — `@symbiote-native/notifications/react`, `/vue`,
+Identical import surface on every adapter - `@symbiote-native/notifications/react`, `/vue`,
 `/svelte`, `/solid`, `/angular` all re-export the same functions.
 
 ## API
@@ -172,7 +179,7 @@ getNotificationCategoriesAsync(): Promise<INotificationCategory[]>
 setNotificationCategoryAsync(identifier: string, actions: INotificationAction[], options?: INotificationCategoryOptions): Promise<INotificationCategory>
 deleteNotificationCategoryAsync(identifier: string): Promise<boolean>
 
-// channels — @platform android (no-op returning [] / null / void off Android)
+// channels - @platform android (no-op returning [] / null / void off Android)
 getNotificationChannelsAsync(): Promise<INotificationChannel[]>
 getNotificationChannelAsync(channelId: string): Promise<INotificationChannel | null>
 setNotificationChannelAsync(channelId: string, channel: INotificationChannelInput): Promise<INotificationChannel | null>
@@ -197,35 +204,43 @@ registerTaskAsync(taskName: string): Promise<null>
 unregisterTaskAsync(taskName: string): Promise<null>
 ```
 
+Per-adapter: `useLastNotificationResponse()` (React/Vue/Solid/Svelte) /
+`inject(LastNotificationResponseService).connect()` (Angular) - the last tapped/received response,
+deduped by notification identifier, kept in sync with `addNotificationResponseReceivedListener` and
+`addNotificationResponseClearedListener`.
+
 Plus the enums `IosAlertStyle`, `IosAllowsPreviews`, `IosAuthorizationStatus`,
 `AndroidNotificationVisibility`, `AndroidAudioContentType`, `AndroidImportance`,
 `AndroidAudioUsage`, `AndroidNotificationPriority`, `SchedulableTriggerInputTypes`,
 `BackgroundNotificationTaskResult`, `PermissionStatus` (re-exported from `expo-modules-core`, same
 precedent `@symbiote-native/sensors` uses), and the full `I`-prefixed type surface for content,
-triggers, and native-facing payloads — see `src/core/types.ts`.
-
-## What this port deliberately does not carry over from upstream
-
-- **No automatic push-token server-resync daemon.** Upstream's `DevicePushTokenAutoRegistration.fx.ts`
-  wires a permanent, module-load background listener that re-POSTs a rolled device token to Expo's
-  push backend with exponential retry/backoff (via the `abort-controller` package), whenever
-  registration was left enabled. This port ships `setAutoServerRegistrationEnabledAsync` (used
-  internally by `getExpoPushTokenAsync`) but not the daemon itself — call `getExpoPushTokenAsync()`
-  again from your own `addPushTokenListener` callback for the same effect, without an unconditional
-  background retry loop and its extra dependency.
-- **No `expo-constants`/`expo-application` defaults.** Upstream's `getExpoPushTokenAsync` fills in
-  `projectId` from `Constants.expoConfig.extra.eas.projectId` and `applicationId` from
-  `Application.applicationId` when omitted. Neither package is part of this port (per the
-  `symbiote-expo-native-module` skill, this project depends on `expo-modules-core` only) — pass
-  both explicitly. [`@symbiote-native/application`](../application)'s own `applicationId` export
-  covers the second one.
-- **No `useLastNotificationResponse` React hook.** This package's whole surface is
-  adapter-agnostic plain functions by design — read the last response with
-  `getLastNotificationResponse()` and subscribe to changes with
-  `addNotificationResponseClearedListener`/`addNotificationResponseReceivedListener` directly in
-  whichever lifecycle your framework prefers.
-- **The deprecated `*Async` aliases for `getLastNotificationResponse`/`clearLastNotificationResponse`**
-  are not ported — call the non-`Async` forms upstream itself now recommends.
+triggers, and native-facing payloads - see `src/core/types.ts`.
+
+## Push-token resync and defaults
+
+- **Token resync is ported, and explicit.** Upstream's `DevicePushTokenAutoRegistration.fx.ts`
+  re-POSTs a rolled device token to Expo's push backend with exponential backoff whenever
+  registration was left enabled. Here it is `installPushTokenAutoRegistration()` (`core/auto-registration.ts`,
+  with the upstream `backoff`/`updateDevicePushTokenAsync` helpers and their tests): idempotent, and
+  installed by `setAutoServerRegistrationEnabledAsync(true)` (so also by `getExpoPushTokenAsync`). Call it
+  once at app startup as well, so a token that rolled while the app was closed is re-sent too. It is
+  explicit rather than a module-load side effect because Metro's `inlineRequires` skips a barrel
+  re-export that nothing names as a value.
+- **`applicationId` and `development` default like upstream**, from
+  [`@symbiote-native/application`](../application) (its `applicationId` and the iOS push-notification
+  service environment). `projectId` still has to be passed: upstream reads it from
+  `expo-constants`, and `@symbiote-native/constants` does not exist yet.
+- **`useLastNotificationResponse` is ported to every adapter** (React, Vue, Solid, Svelte,
+  Angular) - each wraps `getLastNotificationResponse()` +
+  `addNotificationResponseClearedListener`/`addNotificationResponseReceivedListener` with the
+  shared `determineNextResponse` dedup rule from `core/last-notification-response.ts` behind its
+  own lifecycle (hook/composable/primitive/rune/service). Angular's `LastNotificationResponseService`
+  matches `PreventScreenCaptureService`'s `connect()` shape.
+- **The deprecated `getLastNotificationResponseAsync`/`clearLastNotificationResponseAsync`** are ported
+  too, as thin wrappers over the sync forms, exactly like upstream.
+
+## Scope exclusions
+
 - **`SetBadgeCountOptions.web`** (a `badgin` options bag) is web-only; this project targets
   iOS/Android and `setBadgeCountAsync` takes no options here.
 
@@ -237,22 +252,43 @@ triggers, and native-facing payloads — see `src/core/types.ts`.
   separate build step per platform to exploit that split for, so each function branches on
   `Platform.OS === 'android'` at runtime instead. Off Android they resolve to the same documented
   no-op values (`[]`/`null`/void) without touching native.
-- **13 native modules autolink from one `expo-notifications` install** —
+- **13 native modules autolink from one `expo-notifications` install** -
   `ExpoNotificationPermissionsModule`, `ExpoPushTokenManager`, `ExpoTopicSubscriptionModule`,
   `NotificationsServerRegistrationModule`, `ExpoNotificationPresenter`, `ExpoBadgeModule`,
   `ExpoNotificationScheduler`, `ExpoNotificationCategoriesModule`,
   `ExpoNotificationChannelManager`, `ExpoNotificationChannelGroupManager`,
   `ExpoNotificationsHandlerModule`, `ExpoNotificationsEmitter`,
-  `ExpoBackgroundNotificationTasksModule` — see `native-link.json`.
-- **`setNotificationHandler`'s callback must respond within 3 seconds**, matching upstream — a
+  `ExpoBackgroundNotificationTasksModule` - see `native-link.json`.
+- **Push does not work on emulators or simulators.** Test remote push on a physical device; local
+  notifications work everywhere.
+- **`setNotificationHandler`'s callback must respond within 3 seconds**, matching upstream - a
   slow `handleNotification` implementation causes native to discard the notification and call
   `handleError` with a `NotificationTimeoutError` instead.
 
+## Common questions
+
+- **No push token.** Pass `projectId`. On Android create a channel first (`setNotificationChannelAsync`
+  before `getExpoPushTokenAsync`; Android 13's prompt needs a channel) and set up FCM credentials and
+  `google-services.json`.
+- **Nothing shows while the app is open.** Call `setNotificationHandler` with `shouldShowBanner` and
+  `shouldShowList` `true`.
+- **Silent or late on Android.** Create the channel with high importance and send `priority: 'high'`.
+- **Nothing when the app is closed.** Check the token is registered on the server, FCM V1 credentials
+  on Android, and test on a physical device.
+- **Which notification was tapped?** `useLastNotificationResponse` or
+  `addNotificationResponseReceivedListener`.
+- **Reminders need push?** No: scheduled local notifications need no Firebase or APNs.
+
+Sources: [Expo docs: Notifications](https://docs.expo.dev/versions/latest/sdk/notifications/),
+[Expo docs: push notifications setup](https://docs.expo.dev/push-notifications/push-notifications-setup/),
+[expo/expo#49638](https://github.com/expo/expo/issues/49638),
+[expo/expo#9745](https://github.com/expo/expo/issues/9745).
+
 ## Test it
 
-No Fabric/Descriptor angle at all — every function here is a pure async-function surface plus
+No Fabric/Descriptor angle at all - every function here is a pure async-function surface plus
 event-emitter subscriptions, never a view or per-instance state. Tests inject a fake native-module
 object in place of the real `requireNativeModule` resolution (`vi.mock('./native-modules', …)`)
 and, for the emitter/handler modules, a fake `LegacyEventEmitter` whose listener registry is
-shared across instances so a test can fire an event the same way native would — no `installFabric()`,
+shared across instances so a test can fire an event the same way native would - no `installFabric()`,
 no ViewConfig. See `src/core/*.test.ts`.

package/build/angular/index.d.ts

@@ -1 +1,2 @@
 export * from '../core';
+export { LastNotificationResponseService } from './services/last-notification-response.service';

package/build/angular/index.js

@@ -1 +1,2 @@
 export * from '../core/index.js';
+export { LastNotificationResponseService } from './services/last-notification-response.service/index.js';

package/build/angular/services/last-notification-response.service/index.d.ts

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import type { IMaybeNotificationResponse } from '../../../core';
+export declare class LastNotificationResponseService {
+    private readonly injector;
+    private readonly lastResponse;
+    private isConnected;
+    connect(): Signal<IMaybeNotificationResponse>;
+}

package/build/angular/services/last-notification-response.service/index.js

@@ -0,0 +1,78 @@
+// Angular twin of `../../../react`'s `useLastNotificationResponse`, `connect()` shape combining
+// `PermissionsService`'s signal return with `ScreenshotListenerService`'s effect+injector cleanup
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, Injectable, Injector, signal, inject, } from '@angular/core';
+import { addNotificationResponseClearedListener, addNotificationResponseReceivedListener, determineNextResponse, getLastNotificationResponse, } from '../../../core/index.js';
+let LastNotificationResponseService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var LastNotificationResponseService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            LastNotificationResponseService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        lastResponse = signal(undefined);
+        isConnected = false;
+        connect() {
+            if (!this.isConnected) {
+                this.isConnected = true;
+                effect(onCleanup => {
+                    this.lastResponse.update(prev => determineNextResponse(prev, getLastNotificationResponse()));
+                    const subscription = addNotificationResponseReceivedListener(next => {
+                        this.lastResponse.update(prev => determineNextResponse(prev, next));
+                    });
+                    const clearedSubscription = addNotificationResponseClearedListener(() => {
+                        this.lastResponse.set(null);
+                    });
+                    onCleanup(() => {
+                        subscription.remove();
+                        clearedSubscription.remove();
+                    });
+                }, { injector: this.injector });
+            }
+            return this.lastResponse.asReadonly();
+        }
+    };
+    return LastNotificationResponseService = _classThis;
+})();
+export { LastNotificationResponseService };

package/build/core/auto-registration.d.ts

@@ -0,0 +1,5 @@
+export type IDevicePushTokenRegistration = {
+    isEnabled: boolean;
+};
+export declare function handlePersistedRegistrationInfoAsync(registrationInfo: string | null | undefined): Promise<void>;
+export declare function installPushTokenAutoRegistration(): () => void;

package/build/core/auto-registration.js

@@ -0,0 +1,65 @@
+// Порт `DevicePushTokenAutoRegistration.fx.ts`, ресинк токена на сервер Expo
+import { UnavailabilityError } from 'expo-modules-core';
+import { addPushTokenListener, getDevicePushTokenAsync } from './device-token.js';
+import { serverRegistrationModule } from './native-modules.js';
+import { startAbortableRegistration } from './registration-abort.js';
+import { hasDeviceTokenChangedAsync, updateDevicePushTokenAsync, } from './update-device-push-token.js';
+async function updatePushTokenAsync(token) {
+    if (!(await hasDeviceTokenChangedAsync(token)))
+        return;
+    await updateDevicePushTokenAsync(startAbortableRegistration(), token);
+}
+function isEnabledRegistration(info) {
+    if (!info)
+        return false;
+    try {
+        const registration = JSON.parse(info);
+        return registration?.isEnabled === true;
+    }
+    catch (error) {
+        console.warn('[notifications] Error encountered while fetching registration information for auto token updates.', error);
+        return false;
+    }
+}
+// Досылает токен, если регистрация включена, а сервер его не получил
+export async function handlePersistedRegistrationInfoAsync(registrationInfo) {
+    if (!isEnabledRegistration(registrationInfo))
+        return;
+    try {
+        // Регистрация включена, поэтому запрос "нового" токена безопасен
+        await updatePushTokenAsync(await getDevicePushTokenAsync());
+    }
+    catch (error) {
+        console.warn('[notifications] Error encountered while updating server registration with latest device push token.', error);
+    }
+}
+let removeListener = null;
+// Upstream ставит подписку при загрузке модуля, здесь явно, т.к. под `inlineRequires` barrel
+// не гарантирует выполнение побочного эффекта
+export function installPushTokenAutoRegistration() {
+    if (removeListener)
+        return removeListener;
+    const getRegistrationInfoAsync = serverRegistrationModule.getRegistrationInfoAsync;
+    if (!getRegistrationInfoAsync) {
+        console.warn('[notifications] Error encountered while fetching auto-registration state, new tokens will not be automatically registered on server.', new UnavailabilityError('ServerRegistrationModule', 'getRegistrationInfoAsync'));
+        return () => undefined;
+    }
+    const subscription = addPushTokenListener(async (token) => {
+        try {
+            if (isEnabledRegistration(await serverRegistrationModule.getRegistrationInfoAsync?.())) {
+                await updatePushTokenAsync(token);
+            }
+        }
+        catch (error) {
+            console.warn('[notifications] Error encountered while updating server registration with latest device push token.', error);
+        }
+    });
+    getRegistrationInfoAsync().then(handlePersistedRegistrationInfoAsync, error => {
+        console.error('[notifications] Error reading persisted server registration info: ', error);
+    });
+    removeListener = () => {
+        subscription.remove();
+        removeListener = null;
+    };
+    return removeListener;
+}

package/build/core/backoff.d.ts

@@ -0,0 +1,6 @@
+export declare function computeNextBackoffInterval(initialBackoff: number, previousRetryCount: number, { multiplier, randomizationFactor, minBackoff, maxBackoff, }?: {
+    multiplier?: number | undefined;
+    randomizationFactor?: number | undefined;
+    minBackoff?: number | undefined;
+    maxBackoff?: number | undefined;
+}): number;

package/build/core/backoff.js

@@ -0,0 +1,15 @@
+// Ported from expo-notifications sdk-57 utils/backoff.ts, itself from ide/backoff
+export function computeNextBackoffInterval(initialBackoff, previousRetryCount, { multiplier = 1.5, randomizationFactor = 0.25, minBackoff = initialBackoff, maxBackoff = Infinity, } = {}) {
+    if (initialBackoff <= 0)
+        initialBackoff = 1;
+    if (previousRetryCount < 0)
+        previousRetryCount = 0;
+    if (multiplier < 1)
+        multiplier = 1;
+    if (randomizationFactor < 0 || randomizationFactor > 1)
+        randomizationFactor = 0;
+    const nextBackoff = initialBackoff * multiplier ** previousRetryCount;
+    // Jitter within the negative to positive range of the randomization factor
+    const jitterFactor = 1 - randomizationFactor + 2 * randomizationFactor * Math.random();
+    return Math.min(Math.max(nextBackoff * jitterFactor, minBackoff), maxBackoff);
+}

package/build/core/device-token.d.ts

@@ -0,0 +1,7 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { IDevicePushToken } from './types';
+export type IPushTokenListener = (token: IDevicePushToken) => void;
+/** Fires whenever the OS rolls the device push token while the app is running */
+export declare function addPushTokenListener(listener: IPushTokenListener): EventSubscription;
+/** Returns the native FCM (Android) or APNs (iOS) device push token */
+export declare function getDevicePushTokenAsync(): Promise<IDevicePushToken>;

package/build/core/device-token.js

@@ -0,0 +1,35 @@
+// Отдельно от `tokens.ts`, чтобы `auto-registration.ts` не зависел от него по кругу
+import { Platform, UnavailabilityError, } from 'expo-modules-core';
+import { dlog } from '@symbiote-native/engine';
+import { pushTokenManager } from './native-modules.js';
+// Пакет только под iOS/Android, поэтому `Platform.OS` сужаем один раз здесь, а не кастами
+function nativePlatform() {
+    if (Platform.OS === 'ios' || Platform.OS === 'android') {
+        return Platform.OS;
+    }
+    throw new Error(`[notifications] unsupported platform: ${Platform.OS}`);
+}
+/** Fires whenever the OS rolls the device push token while the app is running */
+export function addPushTokenListener(listener) {
+    return pushTokenManager.addListener('onDevicePushToken', ({ devicePushToken }) => {
+        listener({ data: devicePushToken, type: nativePlatform() });
+    });
+}
+let nativeTokenPromise = null;
+/** Returns the native FCM (Android) or APNs (iOS) device push token */
+export async function getDevicePushTokenAsync() {
+    if (!pushTokenManager.getDevicePushTokenAsync) {
+        throw new UnavailabilityError('Notifications', 'getDevicePushTokenAsync');
+    }
+    let devicePushToken;
+    if (nativeTokenPromise) {
+        devicePushToken = await nativeTokenPromise;
+    }
+    else {
+        nativeTokenPromise = pushTokenManager.getDevicePushTokenAsync();
+        devicePushToken = await nativeTokenPromise;
+        nativeTokenPromise = null;
+    }
+    dlog('[notifications] getDevicePushTokenAsync resolved');
+    return { type: nativePlatform(), data: devicePushToken };
+}

package/build/core/emitter.d.ts

@@ -20,5 +20,9 @@ export declare function getLastNotificationResponse(): INotificationResponse | n
  * be re-applied on the next read.
  */
 export declare function clearLastNotificationResponse(): void;
+/** @deprecated Use `getLastNotificationResponse` instead */
+export declare function getLastNotificationResponseAsync(): Promise<INotificationResponse | null>;
+/** @deprecated Use `clearLastNotificationResponse` instead */
+export declare function clearLastNotificationResponseAsync(): Promise<void>;
 /** Fires whenever `clearLastNotificationResponse` runs. */
 export declare function addNotificationResponseClearedListener(listener: () => void): EventSubscription;

package/build/core/emitter.js

@@ -52,6 +52,14 @@ export function clearLastNotificationResponse() {
     notificationsEmitterModule.clearLastNotificationResponse();
     emitter.emit(RESPONSE_CLEARED_EVENT, []);
 }
+/** @deprecated Use `getLastNotificationResponse` instead */
+export async function getLastNotificationResponseAsync() {
+    return getLastNotificationResponse();
+}
+/** @deprecated Use `clearLastNotificationResponse` instead */
+export async function clearLastNotificationResponseAsync() {
+    clearLastNotificationResponse();
+}
 /** Fires whenever `clearLastNotificationResponse` runs. */
 export function addNotificationResponseClearedListener(listener) {
     return emitter.addListener(RESPONSE_CLEARED_EVENT, listener);

package/build/core/index.d.ts

@@ -1,12 +1,14 @@
 export { getPermissionsAsync, requestPermissionsAsync } from './permissions';
 export { addPushTokenListener, getDevicePushTokenAsync, getExpoPushTokenAsync, setAutoServerRegistrationEnabledAsync, subscribeToTopicAsync, unregisterForNotificationsAsync, unsubscribeFromTopicAsync, type IPushTokenListener, } from './tokens';
+export { installPushTokenAutoRegistration, type IDevicePushTokenRegistration, } from './auto-registration';
 export { dismissAllNotificationsAsync, dismissNotificationAsync, getPresentedNotificationsAsync, } from './presenter';
 export { getBadgeCountAsync, setBadgeCountAsync } from './badge';
 export { cancelAllScheduledNotificationsAsync, cancelScheduledNotificationAsync, getAllScheduledNotificationsAsync, getNextTriggerDateAsync, scheduleNotificationAsync, } from './scheduler';
 export { deleteNotificationCategoryAsync, getNotificationCategoriesAsync, setNotificationCategoryAsync, } from './categories';
 export { deleteNotificationChannelAsync, deleteNotificationChannelGroupAsync, getNotificationChannelAsync, getNotificationChannelGroupAsync, getNotificationChannelGroupsAsync, getNotificationChannelsAsync, setNotificationChannelAsync, setNotificationChannelGroupAsync, } from './channels';
 export { NotificationTimeoutError, setNotificationHandler } from './handler';
-export { DEFAULT_ACTION_IDENTIFIER, addNotificationReceivedListener, addNotificationResponseClearedListener, addNotificationResponseReceivedListener, addNotificationsDroppedListener, clearLastNotificationResponse, getLastNotificationResponse, } from './emitter';
+export { DEFAULT_ACTION_IDENTIFIER, addNotificationReceivedListener, addNotificationResponseClearedListener, addNotificationResponseReceivedListener, addNotificationsDroppedListener, clearLastNotificationResponse, clearLastNotificationResponseAsync, getLastNotificationResponse, getLastNotificationResponseAsync, } from './emitter';
 export { BackgroundNotificationTaskResult, registerTaskAsync, unregisterTaskAsync, } from './background-task';
+export { determineNextResponse } from './last-notification-response';
 export type { IAudioAttributes, IAudioAttributesInput, IBeaconRegion, ICalendarNotificationTrigger, ICalendarTriggerInput, IChannelAwareTriggerInput, ICircularRegion, IDailyNotificationTrigger, IDailyTriggerInput, IDateTriggerInput, IDevicePushToken, IExpoPushToken, IExpoPushTokenOptions, IFirebaseRemoteMessage, IFirebaseRemoteMessageNotification, IInterruptionLevel, IIosNotificationPermissionsRequest, ILocationNotificationTrigger, IMaybeNotificationResponse, IMonthlyNotificationTrigger, IMonthlyTriggerInput, INativeCalendarTriggerInput, INativeChannelAwareTriggerInput, INativeDailyTriggerInput, INativeDateTriggerInput, INativeDevicePushToken, INativeMonthlyTriggerInput, INativeNotificationTriggerInput, INativeTimeIntervalTriggerInput, INativeWeeklyTriggerInput, INativeYearlyTriggerInput, INotification, INotificationAction, INotificationBehavior, INotificationCategory, INotificationCategoryOptions, INotificationChannel, INotificationChannelGroup, INotificationChannelGroupInput, INotificationChannelInput, INotificationContent, INotificationContentAndroid, INotificationContentAttachmentIos, INotificationContentInput, INotificationContentIos, INotificationHandler, INotificationPermissionsRequest, INotificationPermissionsStatus, INotificationRequest, INotificationRequestInput, INotificationResponse, INotificationTaskPayload, INotificationTrigger, INotificationTriggerInput, IPushNotificationTrigger, IRegion, ISchedulableNotificationTriggerInput, ITimeIntervalNotificationTrigger, ITimeIntervalTriggerInput, IUnknownNotificationTrigger, IWeeklyNotificationTrigger, IWeeklyTriggerInput, IYearlyNotificationTrigger, IYearlyTriggerInput, PermissionExpiration, PermissionResponse, } from './types';
 export { AndroidAudioContentType, AndroidAudioUsage, AndroidImportance, AndroidNotificationPriority, AndroidNotificationVisibility, IosAlertStyle, IosAllowsPreviews, IosAuthorizationStatus, PermissionStatus, SchedulableTriggerInputTypes, } from './types';

package/build/core/index.js

@@ -1,11 +1,13 @@
 export { getPermissionsAsync, requestPermissionsAsync } from './permissions.js';
 export { addPushTokenListener, getDevicePushTokenAsync, getExpoPushTokenAsync, setAutoServerRegistrationEnabledAsync, subscribeToTopicAsync, unregisterForNotificationsAsync, unsubscribeFromTopicAsync, } from './tokens.js';
+export { installPushTokenAutoRegistration, } from './auto-registration.js';
 export { dismissAllNotificationsAsync, dismissNotificationAsync, getPresentedNotificationsAsync, } from './presenter.js';
 export { getBadgeCountAsync, setBadgeCountAsync } from './badge.js';
 export { cancelAllScheduledNotificationsAsync, cancelScheduledNotificationAsync, getAllScheduledNotificationsAsync, getNextTriggerDateAsync, scheduleNotificationAsync, } from './scheduler.js';
 export { deleteNotificationCategoryAsync, getNotificationCategoriesAsync, setNotificationCategoryAsync, } from './categories.js';
 export { deleteNotificationChannelAsync, deleteNotificationChannelGroupAsync, getNotificationChannelAsync, getNotificationChannelGroupAsync, getNotificationChannelGroupsAsync, getNotificationChannelsAsync, setNotificationChannelAsync, setNotificationChannelGroupAsync, } from './channels.js';
 export { NotificationTimeoutError, setNotificationHandler } from './handler.js';
-export { DEFAULT_ACTION_IDENTIFIER, addNotificationReceivedListener, addNotificationResponseClearedListener, addNotificationResponseReceivedListener, addNotificationsDroppedListener, clearLastNotificationResponse, getLastNotificationResponse, } from './emitter.js';
+export { DEFAULT_ACTION_IDENTIFIER, addNotificationReceivedListener, addNotificationResponseClearedListener, addNotificationResponseReceivedListener, addNotificationsDroppedListener, clearLastNotificationResponse, clearLastNotificationResponseAsync, getLastNotificationResponse, getLastNotificationResponseAsync, } from './emitter.js';
 export { BackgroundNotificationTaskResult, registerTaskAsync, unregisterTaskAsync, } from './background-task.js';
+export { determineNextResponse } from './last-notification-response.js';
 export { AndroidAudioContentType, AndroidAudioUsage, AndroidImportance, AndroidNotificationPriority, AndroidNotificationVisibility, IosAlertStyle, IosAllowsPreviews, IosAuthorizationStatus, PermissionStatus, SchedulableTriggerInputTypes, } from './types.js';

package/build/core/last-notification-response.d.ts

@@ -0,0 +1,2 @@
+import type { IMaybeNotificationResponse, INotificationResponse } from './types';
+export declare function determineNextResponse(prevResponse: IMaybeNotificationResponse, newResponse: INotificationResponse | null): IMaybeNotificationResponse;

package/build/core/last-notification-response.js

@@ -0,0 +1,12 @@
+// Framework-agnostic twin of expo-notifications' `determineNextResponse` - every adapter's
+// `useLastNotificationResponse` shares this dedup rule instead of re-deriving it
+export function determineNextResponse(prevResponse, newResponse) {
+    if (!newResponse)
+        return null;
+    if (!prevResponse)
+        return newResponse;
+    return prevResponse.notification.request.identifier !==
+        newResponse.notification.request.identifier
+        ? newResponse
+        : prevResponse;
+}

package/build/core/registration-abort.d.ts

@@ -0,0 +1,2 @@
+export declare function abortPendingRegistration(): void;
+export declare function startAbortableRegistration(): AbortSignal;

package/build/core/registration-abort.js

@@ -0,0 +1,10 @@
+// Один активный запрос ресинка токена, новый прерывает предыдущий
+let lastAbortController = null;
+export function abortPendingRegistration() {
+    lastAbortController?.abort();
+}
+export function startAbortableRegistration() {
+    abortPendingRegistration();
+    lastAbortController = new AbortController();
+    return lastAbortController.signal;
+}

package/build/core/token-metadata.d.ts

@@ -0,0 +1,4 @@
+import type { IDevicePushToken } from './types';
+export declare function getDeviceIdAsync(): Promise<string>;
+export declare function getTypeOfToken(devicePushToken: IDevicePushToken): string;
+export declare function shouldUseDevelopmentNotificationService(): Promise<boolean>;