@symbiote-native/notifications 0.1.1 → 0.1.3

package/src/core/tokens.ts

@@ -1,78 +1,35 @@
-// Ported from expo-notifications @ sdk-57's getDevicePushTokenAsync.ts, getExpoPushTokenAsync.ts,
-// unregisterForNotificationsAsync.ts, topicSubscription.ts, TokenEmitter.ts, and the
-// `setAutoServerRegistrationEnabledAsync` half of DevicePushTokenAutoRegistration.fx.ts.
-//
-// ponytail: upstream's DevicePushTokenAutoRegistration.fx.ts also wires a permanent, module-load
-// background daemon that re-POSTs the device token to Expo's push backend on every token change
-// (with exponential backoff, via `abort-controller`) whenever registration was left enabled.
-// That auto-resync daemon is NOT ported — an app that wants it can call
-// `getExpoPushTokenAsync()` again from its own `addPushTokenListener` callback, which is the
-// same effect without a permanent background retry loop and its extra dependency.
-import {
-  CodedError,
-  Platform,
-  UnavailabilityError,
-  type EventSubscription,
-} from 'expo-modules-core';
+// Порт токенов из upstream sdk-57, фоновый ресинк токена живёт в `auto-registration.ts`
+import { applicationId } from '@symbiote-native/application';
+import { CodedError, UnavailabilityError } from 'expo-modules-core';
 
 import { dlog } from '@symbiote-native/engine';
 
+import { installPushTokenAutoRegistration } from './auto-registration';
+import { getDevicePushTokenAsync } from './device-token';
 import {
   pushTokenManager,
   serverRegistrationModule,
   topicSubscriptionModule,
 } from './native-modules';
+import { abortPendingRegistration } from './registration-abort';
+import {
+  getDeviceIdAsync,
+  getTypeOfToken,
+  shouldUseDevelopmentNotificationService,
+} from './token-metadata';
 import type {
   IDevicePushToken,
   IExpoPushToken,
   IExpoPushTokenOptions,
 } from './types';
 
-const PRODUCTION_BASE_URL = 'https://exp.host/--/api/v2/';
-
-// This package targets iOS/Android only (root CLAUDE.md); narrow `Platform.OS` at the one
-// boundary that needs it rather than casting at every call site.
-function nativePlatform(): 'ios' | 'android' {
-  if (Platform.OS === 'ios' || Platform.OS === 'android') {
-    return Platform.OS;
-  }
-  throw new Error(`[notifications] unsupported platform: ${Platform.OS}`);
-}
-
-export type IPushTokenListener = (token: IDevicePushToken) => void;
-
-/** Fires whenever the OS rolls the device push token while the app is running. */
-export function addPushTokenListener(
-  listener: IPushTokenListener,
-): EventSubscription {
-  return pushTokenManager.addListener(
-    'onDevicePushToken',
-    ({ devicePushToken }) => {
-      listener({ data: devicePushToken, type: nativePlatform() });
-    },
-  );
-}
-
-let nativeTokenPromise: Promise<string> | null = null;
+export {
+  addPushTokenListener,
+  getDevicePushTokenAsync,
+  type IPushTokenListener,
+} from './device-token';
 
-/** Returns the native FCM (Android) or APNs (iOS) device push token. */
-export async function getDevicePushTokenAsync(): Promise<IDevicePushToken> {
-  if (!pushTokenManager.getDevicePushTokenAsync) {
-    throw new UnavailabilityError('Notifications', 'getDevicePushTokenAsync');
-  }
-
-  let devicePushToken: string;
-  if (nativeTokenPromise) {
-    devicePushToken = await nativeTokenPromise;
-  } else {
-    nativeTokenPromise = pushTokenManager.getDevicePushTokenAsync();
-    devicePushToken = await nativeTokenPromise;
-    nativeTokenPromise = null;
-  }
-
-  dlog('[notifications] getDevicePushTokenAsync resolved');
-  return { type: nativePlatform(), data: devicePushToken };
-}
+const PRODUCTION_BASE_URL = 'https://exp.host/--/api/v2/';
 
 /** Unregisters the device from receiving remote push notifications entirely. */
 export async function unregisterForNotificationsAsync(): Promise<void> {
@@ -101,14 +58,13 @@ export async function unsubscribeFromTopicAsync(topic: string): Promise<null> {
   return topicSubscriptionModule.unsubscribeFromTopicAsync(topic);
 }
 
-/**
- * Enables/disables letting the OS-level registration blob persist whether the device push
- * token should keep being pushed to the Expo push service backend. See the module doc comment
- * above for what this deliberately does *not* do (the auto-resync daemon).
- */
+/** Persists whether the device push token keeps being pushed to the Expo push service */
 export async function setAutoServerRegistrationEnabledAsync(
   enabled: boolean,
 ): Promise<void> {
+  // Перезаписываем регистрацию, поэтому висящий запрос не должен завершиться
+  abortPendingRegistration();
+
   if (!serverRegistrationModule.setRegistrationInfoAsync) {
     throw new UnavailabilityError('Notifications', 'setRegistrationInfoAsync');
   }
@@ -131,29 +87,7 @@ export async function setAutoServerRegistrationEnabledAsync(
   await serverRegistrationModule.setRegistrationInfoAsync(
     JSON.stringify(existing),
   );
-}
-
-async function getDeviceIdAsync(): Promise<string> {
-  try {
-    if (!serverRegistrationModule.getInstallationIdAsync) {
-      throw new UnavailabilityError('Notifications', 'getInstallationIdAsync');
-    }
-    return await serverRegistrationModule.getInstallationIdAsync();
-  } catch (error) {
-    throw new CodedError(
-      'ERR_NOTIF_DEVICE_ID',
-      `Could not fetch the installation ID of the application: ${error}.`,
-    );
-  }
-}
-
-function getTypeOfToken(devicePushToken: IDevicePushToken): string {
-  switch (devicePushToken.type) {
-    case 'ios':
-      return 'apns';
-    case 'android':
-      return 'fcm';
-  }
+  installPushTokenAutoRegistration();
 }
 
 function getDeviceToken(devicePushToken: IDevicePushToken): string {
@@ -189,50 +123,10 @@ function extractExpoPushToken(data: unknown): string {
   );
 }
 
-/**
- * Returns an Expo push token usable with Expo's push notification relay service. Makes a
- * network request to Expo's servers — wrap in try/catch and retry once the device is back
- * online.
- *
- * ponytail: upstream auto-fills `projectId`/`applicationId`/`development` from
- * `expo-constants`/`expo-application`. Neither package is part of this port, so pass them
- * explicitly (`applicationId` from `@symbiote-native/application`'s own `applicationId` export
- * covers the second one).
- */
-export async function getExpoPushTokenAsync(
-  options: IExpoPushTokenOptions = {},
-): Promise<IExpoPushToken> {
-  const devicePushToken =
-    options.devicePushToken ?? (await getDevicePushTokenAsync());
-  const deviceId = options.deviceId ?? (await getDeviceIdAsync());
-
-  if (!options.projectId) {
-    throw new CodedError(
-      'ERR_NOTIFICATIONS_NO_EXPERIENCE_ID',
-      'No "projectId" was passed to getExpoPushTokenAsync(). This port does not read expo-constants — pass it explicitly.',
-    );
-  }
-  if (!options.applicationId) {
-    throw new CodedError(
-      'ERR_NOTIFICATIONS_NO_APPLICATION_ID',
-      'No "applicationId" was passed to getExpoPushTokenAsync(). This port does not read expo-application — pass it explicitly (e.g. @symbiote-native/application\'s `applicationId`).',
-    );
-  }
-
-  const type = options.type ?? getTypeOfToken(devicePushToken);
-  const development = options.development ?? false;
-  const baseUrl = options.baseUrl ?? PRODUCTION_BASE_URL;
-  const url = options.url ?? `${baseUrl}push/getExpoPushToken`;
-
-  const body = {
-    type,
-    deviceId: deviceId.toLowerCase(),
-    development,
-    appId: options.applicationId,
-    deviceToken: getDeviceToken(devicePushToken),
-    projectId: options.projectId,
-  };
-
+async function requestExpoPushTokenAsync(
+  url: string,
+  body: Record<string, unknown>,
+): Promise<string> {
   let response: Response;
   try {
     response = await fetch(url, {
@@ -254,7 +148,51 @@ export async function getExpoPushTokenAsync(
     );
   }
 
-  const expoPushToken = extractExpoPushToken(await parseJsonResponse(response));
+  return extractExpoPushToken(await parseJsonResponse(response));
+}
+
+// Вынесено, чтобы `getExpoPushTokenAsync` читался как запрос токена и регистрация
+async function buildExpoPushTokenBody(
+  options: IExpoPushTokenOptions,
+  devicePushToken: IDevicePushToken,
+): Promise<Record<string, unknown>> {
+  if (!options.projectId) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_NO_EXPERIENCE_ID',
+      'No "projectId" was passed to getExpoPushTokenAsync(). Pass it explicitly (this port has no expo-constants).',
+    );
+  }
+  const appId = options.applicationId ?? applicationId;
+  if (!appId) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_NO_APPLICATION_ID',
+      'No "applicationId" was passed to getExpoPushTokenAsync() and the app has none of its own.',
+    );
+  }
+
+  const deviceId = options.deviceId ?? (await getDeviceIdAsync());
+  return {
+    type: options.type ?? getTypeOfToken(devicePushToken),
+    deviceId: deviceId.toLowerCase(),
+    development:
+      options.development ?? (await shouldUseDevelopmentNotificationService()),
+    appId,
+    deviceToken: getDeviceToken(devicePushToken),
+    projectId: options.projectId,
+  };
+}
+
+/** Returns an Expo push token for Expo's push relay, needs network so retry when back online */
+export async function getExpoPushTokenAsync(
+  options: IExpoPushTokenOptions = {},
+): Promise<IExpoPushToken> {
+  const devicePushToken =
+    options.devicePushToken ?? (await getDevicePushTokenAsync());
+  const body = await buildExpoPushTokenBody(options, devicePushToken);
+  const baseUrl = options.baseUrl ?? PRODUCTION_BASE_URL;
+  const url = options.url ?? `${baseUrl}push/getExpoPushToken`;
+
+  const expoPushToken = await requestExpoPushTokenAsync(url, body);
 
   if (!options.url && !options.baseUrl) {
     try {

package/src/core/update-device-push-token.ts

@@ -0,0 +1,173 @@
+// Порт `utils/updateDevicePushTokenAsync.ts` из upstream sdk-57
+import { applicationId } from '@symbiote-native/application';
+import { dlog } from '@symbiote-native/engine';
+
+import { computeNextBackoffInterval } from './backoff';
+import { serverRegistrationModule } from './native-modules';
+import {
+  getDeviceIdAsync,
+  getTypeOfToken,
+  shouldUseDevelopmentNotificationService,
+} from './token-metadata';
+import type { IDevicePushToken } from './types';
+
+const UPDATE_DEVICE_PUSH_TOKEN_URL =
+  'https://exp.host/--/api/v2/push/updateDeviceToken';
+const LAST_TOKEN_KEY = 'lastRegisteredDeviceToken';
+const INITIAL_BACKOFF_MS = 500;
+const MAX_BACKOFF_MS = 2 * 60 * 1000;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+
+// Повторная регистрация раз в 7 дней, т.к. сервер мог потерять запись об устройстве
+const REGISTRATION_TTL_MS = 7 * MS_PER_DAY;
+
+type IStoredTokenData = {
+  deviceToken: string;
+  appId: string | null;
+  development: boolean;
+  type: string;
+  registeredAt: number;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function isStoredTokenData(value: unknown): value is IStoredTokenData {
+  return (
+    isRecord(value) &&
+    typeof value.deviceToken === 'string' &&
+    typeof value.development === 'boolean' &&
+    typeof value.type === 'string' &&
+    typeof value.registeredAt === 'number'
+  );
+}
+
+async function getLastRegisteredTokenDataAsync(): Promise<IStoredTokenData | null> {
+  try {
+    if (!serverRegistrationModule.getRegistrationInfoAsync) return null;
+    const info = await serverRegistrationModule.getRegistrationInfoAsync();
+    if (!info) return null;
+    const stored: unknown = JSON.parse(info)?.[LAST_TOKEN_KEY];
+    return isStoredTokenData(stored) ? stored : null;
+  } catch {
+    return null;
+  }
+}
+
+async function setLastRegisteredTokenDataAsync(
+  tokenData: IStoredTokenData,
+): Promise<void> {
+  try {
+    if (
+      !serverRegistrationModule.getRegistrationInfoAsync ||
+      !serverRegistrationModule.setRegistrationInfoAsync
+    ) {
+      return;
+    }
+    const info = await serverRegistrationModule.getRegistrationInfoAsync();
+    const existing = info ? JSON.parse(info) : {};
+    existing[LAST_TOKEN_KEY] = tokenData;
+    await serverRegistrationModule.setRegistrationInfoAsync(
+      JSON.stringify(existing),
+    );
+  } catch {
+    // Best-effort, при следующем запуске приложение зарегистрируется снова
+  }
+}
+
+// Если проверка невозможна, считаем токен изменившимся (fail-open)
+export async function hasDeviceTokenChangedAsync(
+  token: IDevicePushToken,
+): Promise<boolean> {
+  try {
+    const development = await shouldUseDevelopmentNotificationService();
+    const lastTokenData = await getLastRegisteredTokenDataAsync();
+
+    if (lastTokenData == null) return true;
+
+    const age = Date.now() - lastTokenData.registeredAt;
+    if (age < 0 || age >= REGISTRATION_TTL_MS) return true;
+
+    return (
+      token.data !== lastTokenData.deviceToken ||
+      applicationId !== lastTokenData.appId ||
+      development !== lastTokenData.development ||
+      getTypeOfToken(token) !== lastTokenData.type
+    );
+  } catch {
+    return true;
+  }
+}
+
+// `true` значит запрос надо повторить
+async function sendTokenOnceAsync(
+  signal: AbortSignal,
+  token: IDevicePushToken,
+): Promise<boolean> {
+  const [development, deviceId] = await Promise.all([
+    shouldUseDevelopmentNotificationService(),
+    getDeviceIdAsync(),
+  ]);
+  const type = getTypeOfToken(token);
+
+  try {
+    const response = await fetch(UPDATE_DEVICE_PUSH_TOKEN_URL, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        deviceId: deviceId.toLowerCase(),
+        development,
+        deviceToken: token.data,
+        appId: applicationId,
+        type,
+      }),
+      signal,
+    });
+
+    if (!response.ok) {
+      dlog(
+        `[notifications] device push token update rejected: ${await response.text()}`,
+      );
+      return true;
+    }
+
+    await setLastRegisteredTokenDataAsync({
+      deviceToken: token.data,
+      appId: applicationId,
+      development,
+      type,
+      registeredAt: Date.now(),
+    });
+    return false;
+  } catch (error) {
+    // Прерванный запрос может упасть с `AbortError` или нативной ошибкой отмены
+    if (signal.aborted || (isRecord(error) && error.name === 'AbortError'))
+      return false;
+
+    console.warn(
+      '[notifications] Error thrown while updating the device push token with the server:',
+      error,
+    );
+    return true;
+  }
+}
+
+export async function updateDevicePushTokenAsync(
+  signal: AbortSignal,
+  token: IDevicePushToken,
+): Promise<void> {
+  const backoffOptions = { maxBackoff: MAX_BACKOFF_MS };
+
+  for (let retriesCount = 0; !signal.aborted; retriesCount += 1) {
+    const shouldRetry = await sendTokenOnceAsync(signal, token);
+    if (!shouldRetry || signal.aborted) return;
+
+    const backoff = computeNextBackoffInterval(
+      INITIAL_BACKOFF_MS,
+      retriesCount,
+      backoffOptions,
+    );
+    await new Promise<void>(resolve => setTimeout(resolve, backoff));
+  }
+}

package/src/react/hooks/use-last-notification-response/index.ts

@@ -0,0 +1,35 @@
+// React twin of expo-notifications' `useLastNotificationResponse`. `useLayoutEffect` matches
+// upstream's own choice - the listener must register before paint
+
+import { useLayoutEffect, useState } from 'react';
+import {
+  addNotificationResponseClearedListener,
+  addNotificationResponseReceivedListener,
+  determineNextResponse,
+  getLastNotificationResponse,
+} from '../../../core';
+import type { IMaybeNotificationResponse } from '../../../core';
+
+export function useLastNotificationResponse(): IMaybeNotificationResponse {
+  const [lastResponse, setLastResponse] =
+    useState<IMaybeNotificationResponse>(undefined);
+
+  useLayoutEffect(() => {
+    const response = getLastNotificationResponse();
+    setLastResponse(prev => determineNextResponse(prev, response));
+
+    const subscription = addNotificationResponseReceivedListener(next => {
+      setLastResponse(prev => determineNextResponse(prev, next));
+    });
+    const clearedSubscription = addNotificationResponseClearedListener(() => {
+      setLastResponse(null);
+    });
+
+    return () => {
+      subscription.remove();
+      clearedSubscription.remove();
+    };
+  }, []);
+
+  return lastResponse;
+}

package/src/react/index.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useLastNotificationResponse } from './hooks/use-last-notification-response';

package/src/solid/index.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { createLastNotificationResponse } from './primitives/create-last-notification-response';

package/src/solid/primitives/create-last-notification-response.ts

@@ -0,0 +1,35 @@
+// Solid twin of `../../react`'s `useLastNotificationResponse`
+
+import { createSignal, onCleanup, onMount, type Accessor } from 'solid-js';
+import {
+  addNotificationResponseClearedListener,
+  addNotificationResponseReceivedListener,
+  determineNextResponse,
+  getLastNotificationResponse,
+} from '../../core';
+import type { IMaybeNotificationResponse } from '../../core';
+
+export function createLastNotificationResponse(): Accessor<IMaybeNotificationResponse> {
+  const [lastResponse, setLastResponse] =
+    createSignal<IMaybeNotificationResponse>(undefined);
+
+  onMount(() => {
+    setLastResponse(prev =>
+      determineNextResponse(prev, getLastNotificationResponse()),
+    );
+
+    const subscription = addNotificationResponseReceivedListener(next => {
+      setLastResponse(prev => determineNextResponse(prev, next));
+    });
+    const clearedSubscription = addNotificationResponseClearedListener(() => {
+      setLastResponse(null);
+    });
+
+    onCleanup(() => {
+      subscription.remove();
+      clearedSubscription.remove();
+    });
+  });
+
+  return lastResponse;
+}

package/src/svelte/index.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useLastNotificationResponse } from './use-last-notification-response.svelte';

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,3 @@
+// Pulls svelte's ambient globals ($state/$effect/...) into this package's tsc program,
+// same fix as `packages/navigation/src/svelte/svelte-ambient.d.ts`
+/// <reference types="svelte" />

package/src/svelte/svelte-compile.test-helper.ts

@@ -0,0 +1,7 @@
+// Re-exports the existing harness instead of a third copy (packages/sqlite and
+// packages/navigation already carry one, not part of either package's public exports)
+export {
+  createSvelteHarness,
+  loadComponent,
+  type ISvelteHarness,
+} from '../../../sqlite/src/svelte/svelte-compile.test-helper';

package/src/svelte/use-last-notification-response.svelte.ts

@@ -0,0 +1,45 @@
+// Boxed-getter shape matches `@symbiote-native/screen-capture`'s own runes by design - each
+// package owns its copy rather than depend on a sibling install-optional package
+
+import { untrack } from 'svelte';
+import {
+  addNotificationResponseClearedListener,
+  addNotificationResponseReceivedListener,
+  determineNextResponse,
+  getLastNotificationResponse,
+} from '../core';
+import type { IMaybeNotificationResponse } from '../core';
+
+export function useLastNotificationResponse(): {
+  readonly current: IMaybeNotificationResponse;
+} {
+  let lastResponse = $state<IMaybeNotificationResponse>(undefined);
+
+  $effect(() => {
+    lastResponse = determineNextResponse(
+      untrack(() => lastResponse),
+      getLastNotificationResponse(),
+    );
+
+    const subscription = addNotificationResponseReceivedListener(next => {
+      lastResponse = determineNextResponse(
+        untrack(() => lastResponse),
+        next,
+      );
+    });
+    const clearedSubscription = addNotificationResponseClearedListener(() => {
+      lastResponse = null;
+    });
+
+    return () => {
+      subscription.remove();
+      clearedSubscription.remove();
+    };
+  });
+
+  return {
+    get current(): IMaybeNotificationResponse {
+      return lastResponse;
+    },
+  };
+}

package/src/vue/composables/use-last-notification-response/index.ts

@@ -0,0 +1,35 @@
+// Vue twin of `../../../react`'s `useLastNotificationResponse`
+
+import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
+import {
+  addNotificationResponseClearedListener,
+  addNotificationResponseReceivedListener,
+  determineNextResponse,
+  getLastNotificationResponse,
+} from '../../../core';
+import type { IMaybeNotificationResponse } from '../../../core';
+
+export function useLastNotificationResponse(): Ref<IMaybeNotificationResponse> {
+  const lastResponse = ref<IMaybeNotificationResponse>(undefined);
+
+  onMounted(() => {
+    lastResponse.value = determineNextResponse(
+      lastResponse.value,
+      getLastNotificationResponse(),
+    );
+
+    const subscription = addNotificationResponseReceivedListener(next => {
+      lastResponse.value = determineNextResponse(lastResponse.value, next);
+    });
+    const clearedSubscription = addNotificationResponseClearedListener(() => {
+      lastResponse.value = null;
+    });
+
+    onUnmounted(() => {
+      subscription.remove();
+      clearedSubscription.remove();
+    });
+  });
+
+  return lastResponse;
+}

package/src/vue/index.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useLastNotificationResponse } from './composables/use-last-notification-response';