@webority/mobile-core 0.0.23 → 0.0.24

package/README.md

@@ -29,11 +29,21 @@ import { Geolocation } from '@webority/mobile-core/geolocation';
 import { openDatabase } from '@webority/mobile-core/sqlite';
 import { downloadFile } from '@webority/mobile-core/download';
 import { shareFile } from '@webority/mobile-core/share';
+import { initPush, enablePush, usePush } from '@webority/mobile-core/push';
 import { compressImage } from '@webority/mobile-core/compressor';
 ```
 
 Metro resolves requires statically, so anything reachable from the main barrel is bundled for
 every consumer. Keeping these off it is what makes their peers genuinely optional.
 
+`/push` registers the phone for push notifications. It needs `expo-notifications`, an optional
+peer, and reports `unavailable` without it or in Expo Go. Call `initPush` once at startup with
+`getInstallationId`, `register`, `unregister` and `onOpen`; `enablePush` asks permission, sends
+the native token (`Fcm` on Android, `Apns` on iOS) and the bundle id to `register`, and
+re-registers when the token changes; `disablePush` calls `unregister`. `onOpen` receives the
+tapped notification's data as strings, including the tap that launched the app. `usePush` gives a
+settings switch its `status` and `enabled`. The library does not remember the switch: an app that
+keeps push on calls `enablePush` at each start.
+
 Storage and network status stay on the main barrel but load no package on their own. Wire them at
 startup with `setStorageImplementation` and `setNetworkStatusImplementation` if you want them.

package/lib/commonjs/push/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "disablePush", {
+  enumerable: true,
+  get: function () {
+    return _push.disablePush;
+  }
+});
+Object.defineProperty(exports, "enablePush", {
+  enumerable: true,
+  get: function () {
+    return _push.enablePush;
+  }
+});
+Object.defineProperty(exports, "initPush", {
+  enumerable: true,
+  get: function () {
+    return _push.initPush;
+  }
+});
+Object.defineProperty(exports, "setBadgeCount", {
+  enumerable: true,
+  get: function () {
+    return _push.setBadgeCount;
+  }
+});
+Object.defineProperty(exports, "setPushImplementation", {
+  enumerable: true,
+  get: function () {
+    return _push.setPushImplementation;
+  }
+});
+Object.defineProperty(exports, "usePush", {
+  enumerable: true,
+  get: function () {
+    return _push.usePush;
+  }
+});
+var _push = require("./push.js");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/push/push.js

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePush = exports.setPushImplementation = exports.setBadgeCount = exports.initPush = exports.enablePush = exports.disablePush = void 0;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _index = require("../logger/index.js");
+/** The slice of expo-notifications this module calls, so the optional peer stays untyped at build. */
+
+let override = null;
+
+/** Expo modules resolved once; null when push cannot work in this build. */
+let resolved;
+
+/**
+ * Replace the native modules. For tests and the showcase, to reach paths a
+ * real device never takes; an injected backend is taken on trust, Expo Go
+ * included. Pass `null` to restore expo-notifications.
+ */
+const setPushImplementation = impl => {
+  override = impl;
+};
+
+/**
+ * The only place expo-notifications and expo-application are named. Expo Go is
+ * checked first because expo-notifications refuses remote push there and its
+ * import throws on Android.
+ */
+exports.setPushImplementation = setPushImplementation;
+const resolveModules = () => {
+  if (override) {
+    return override;
+  }
+  if (resolved !== undefined) {
+    return resolved;
+  }
+  try {
+    const expo = require('expo');
+    if (expo.isRunningInExpoGo()) {
+      resolved = null;
+      return resolved;
+    }
+    const notifications = require('expo-notifications');
+    const application = require('expo-application');
+    resolved = {
+      notifications,
+      applicationId: application.applicationId
+    };
+  } catch (error) {
+    _index.Logger.warn('[push] expo-notifications is not available; push is off', error);
+    resolved = null;
+  }
+  return resolved;
+};
+let state = {
+  status: 'unknown',
+  enabled: false
+};
+const subscribers = new Set();
+const setState = next => {
+  state = {
+    ...state,
+    ...next
+  };
+  for (const notify of subscribers) {
+    notify();
+  }
+};
+let config = null;
+let channelsReady = Promise.resolve();
+let tokenSubscription = null;
+let lastOpenedId = null;
+const requireConfig = () => {
+  if (!config) {
+    throw new Error('[@webority/mobile-core] call initPush before enablePush or disablePush.');
+  }
+  return config;
+};
+const toPermissionStatus = response => {
+  if (response.granted) {
+    return 'granted';
+  }
+  return response.status === 'denied' ? 'denied' : 'unknown';
+};
+
+/** Push data travels as strings; iOS can hand back numbers or objects for top-level keys. */
+const toStringData = data => {
+  const out = {};
+  for (const [key, value] of Object.entries(data ?? {})) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    out[key] = typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+  return out;
+};
+const handleResponse = response => {
+  if (!response || !config) {
+    return;
+  }
+  // The cold-start read and the listener can both report the launching tap.
+  const id = `${response.notification.request.identifier}:${response.actionIdentifier}`;
+  if (id === lastOpenedId) {
+    return;
+  }
+  lastOpenedId = id;
+  try {
+    config.onOpen(toStringData(response.notification.request.content.data));
+  } catch (error) {
+    _index.Logger.error('[push] onOpen threw', error);
+  }
+};
+const createChannels = async (m, channels) => {
+  for (const channel of channels) {
+    try {
+      await m.setNotificationChannelAsync(channel.id, {
+        name: channel.name,
+        importance: channel.importance === 'high' ? m.AndroidImportance.HIGH : m.AndroidImportance.DEFAULT
+      });
+    } catch (error) {
+      _index.Logger.error(`[push] creating channel ${channel.id} failed`, error);
+    }
+  }
+};
+const toDevice = async (token, applicationId) => {
+  const platform = token.type === 'android' ? 'Fcm' : token.type === 'ios' ? 'Apns' : null;
+  if (!platform || typeof token.data !== 'string') {
+    return null;
+  }
+  if (!applicationId) {
+    throw new Error('[@webority/mobile-core] push needs the app bundle id from expo-application.');
+  }
+  const installationId = await requireConfig().getInstallationId();
+  return {
+    installationId,
+    platform,
+    token: token.data,
+    appId: applicationId
+  };
+};
+
+/**
+ * Wires push at startup: the foreground handler, Android channels, and tap
+ * handling, including the tap that launched the app. Calling it again only
+ * replaces the config.
+ */
+const initPush = next => {
+  const first = config === null;
+  config = next;
+  if (!first) {
+    return;
+  }
+  const mods = resolveModules();
+  if (!mods) {
+    setState({
+      status: 'unavailable'
+    });
+    return;
+  }
+  const m = mods.notifications;
+  m.setNotificationHandler({
+    handleNotification: async () => {
+      const show = config?.showInForeground?.() ?? true;
+      return {
+        shouldShowBanner: show,
+        shouldShowList: show,
+        shouldPlaySound: show,
+        shouldSetBadge: true
+      };
+    }
+  });
+  if (_reactNative.Platform.OS === 'android' && next.androidChannels?.length) {
+    channelsReady = createChannels(m, next.androidChannels);
+  }
+  m.addNotificationResponseReceivedListener(handleResponse);
+  void m.getLastNotificationResponseAsync().then(response => {
+    handleResponse(response);
+    return m.clearLastNotificationResponseAsync?.();
+  }).catch(error => _index.Logger.error('[push] reading the launch notification failed', error));
+  void m.getPermissionsAsync().then(response => setState({
+    status: toPermissionStatus(response)
+  })).catch(error => _index.Logger.error('[push] permission check failed', error));
+};
+
+/**
+ * Asks for permission, reads the native device token and registers it through
+ * `config.register`, then re-registers whenever the OS rotates the token.
+ */
+exports.initPush = initPush;
+const enablePush = async () => {
+  requireConfig();
+  const mods = resolveModules();
+  if (!mods) {
+    setState({
+      status: 'unavailable'
+    });
+    return 'unavailable';
+  }
+  const m = mods.notifications;
+
+  // Android 13 shows the permission prompt only once a channel exists.
+  await channelsReady;
+  let permission = await m.getPermissionsAsync();
+  if (!permission.granted) {
+    permission = await m.requestPermissionsAsync();
+  }
+  if (!permission.granted) {
+    setState({
+      status: 'denied'
+    });
+    return 'denied';
+  }
+  const device = await toDevice(await m.getDevicePushTokenAsync(), mods.applicationId);
+  if (!device) {
+    setState({
+      status: 'unavailable'
+    });
+    return 'unavailable';
+  }
+  await requireConfig().register(device);
+  tokenSubscription?.remove();
+  tokenSubscription = m.addPushTokenListener(token => {
+    void toDevice(token, mods.applicationId).then(next => next ? requireConfig().register(next) : undefined).catch(error => _index.Logger.error('[push] re-registering a new token failed', error));
+  });
+  setState({
+    status: 'granted',
+    enabled: true
+  });
+  return 'granted';
+};
+
+/**
+ * Unregisters the device through `config.unregister` and stops following token
+ * changes. Taps on notifications already delivered still reach `onOpen`.
+ */
+exports.enablePush = enablePush;
+const disablePush = async () => {
+  const current = requireConfig();
+  await current.unregister(await current.getInstallationId());
+  tokenSubscription?.remove();
+  tokenSubscription = null;
+  setState({
+    enabled: false
+  });
+};
+
+/** Sets the app icon badge; a no-op where push is unavailable or the launcher has no badge. */
+exports.disablePush = disablePush;
+const setBadgeCount = async count => {
+  const mods = resolveModules();
+  if (!mods) {
+    return;
+  }
+  await mods.notifications.setBadgeCountAsync(count);
+};
+exports.setBadgeCount = setBadgeCount;
+const subscribe = notify => {
+  subscribers.add(notify);
+  return () => {
+    subscribers.delete(notify);
+  };
+};
+const getSnapshot = () => state;
+const enable = async () => {
+  await enablePush();
+};
+
+/** Push status for a settings switch, re-rendering when it changes. */
+const usePush = () => {
+  const snapshot = (0, _react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return {
+    ...snapshot,
+    enable,
+    disable: disablePush
+  };
+};
+exports.usePush = usePush;
+//# sourceMappingURL=push.js.map

package/lib/module/push/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { disablePush, enablePush, initPush, setBadgeCount, setPushImplementation, usePush } from "./push.js";
+//# sourceMappingURL=index.js.map

package/lib/module/push/push.js

@@ -0,0 +1,271 @@
+"use strict";
+
+import { useSyncExternalStore } from 'react';
+import { Platform } from 'react-native';
+import { Logger } from "../logger/index.js";
+
+/** The slice of expo-notifications this module calls, so the optional peer stays untyped at build. */
+
+let override = null;
+
+/** Expo modules resolved once; null when push cannot work in this build. */
+let resolved;
+
+/**
+ * Replace the native modules. For tests and the showcase, to reach paths a
+ * real device never takes; an injected backend is taken on trust, Expo Go
+ * included. Pass `null` to restore expo-notifications.
+ */
+export const setPushImplementation = impl => {
+  override = impl;
+};
+
+/**
+ * The only place expo-notifications and expo-application are named. Expo Go is
+ * checked first because expo-notifications refuses remote push there and its
+ * import throws on Android.
+ */
+const resolveModules = () => {
+  if (override) {
+    return override;
+  }
+  if (resolved !== undefined) {
+    return resolved;
+  }
+  try {
+    const expo = require('expo');
+    if (expo.isRunningInExpoGo()) {
+      resolved = null;
+      return resolved;
+    }
+    const notifications = require('expo-notifications');
+    const application = require('expo-application');
+    resolved = {
+      notifications,
+      applicationId: application.applicationId
+    };
+  } catch (error) {
+    Logger.warn('[push] expo-notifications is not available; push is off', error);
+    resolved = null;
+  }
+  return resolved;
+};
+let state = {
+  status: 'unknown',
+  enabled: false
+};
+const subscribers = new Set();
+const setState = next => {
+  state = {
+    ...state,
+    ...next
+  };
+  for (const notify of subscribers) {
+    notify();
+  }
+};
+let config = null;
+let channelsReady = Promise.resolve();
+let tokenSubscription = null;
+let lastOpenedId = null;
+const requireConfig = () => {
+  if (!config) {
+    throw new Error('[@webority/mobile-core] call initPush before enablePush or disablePush.');
+  }
+  return config;
+};
+const toPermissionStatus = response => {
+  if (response.granted) {
+    return 'granted';
+  }
+  return response.status === 'denied' ? 'denied' : 'unknown';
+};
+
+/** Push data travels as strings; iOS can hand back numbers or objects for top-level keys. */
+const toStringData = data => {
+  const out = {};
+  for (const [key, value] of Object.entries(data ?? {})) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    out[key] = typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+  return out;
+};
+const handleResponse = response => {
+  if (!response || !config) {
+    return;
+  }
+  // The cold-start read and the listener can both report the launching tap.
+  const id = `${response.notification.request.identifier}:${response.actionIdentifier}`;
+  if (id === lastOpenedId) {
+    return;
+  }
+  lastOpenedId = id;
+  try {
+    config.onOpen(toStringData(response.notification.request.content.data));
+  } catch (error) {
+    Logger.error('[push] onOpen threw', error);
+  }
+};
+const createChannels = async (m, channels) => {
+  for (const channel of channels) {
+    try {
+      await m.setNotificationChannelAsync(channel.id, {
+        name: channel.name,
+        importance: channel.importance === 'high' ? m.AndroidImportance.HIGH : m.AndroidImportance.DEFAULT
+      });
+    } catch (error) {
+      Logger.error(`[push] creating channel ${channel.id} failed`, error);
+    }
+  }
+};
+const toDevice = async (token, applicationId) => {
+  const platform = token.type === 'android' ? 'Fcm' : token.type === 'ios' ? 'Apns' : null;
+  if (!platform || typeof token.data !== 'string') {
+    return null;
+  }
+  if (!applicationId) {
+    throw new Error('[@webority/mobile-core] push needs the app bundle id from expo-application.');
+  }
+  const installationId = await requireConfig().getInstallationId();
+  return {
+    installationId,
+    platform,
+    token: token.data,
+    appId: applicationId
+  };
+};
+
+/**
+ * Wires push at startup: the foreground handler, Android channels, and tap
+ * handling, including the tap that launched the app. Calling it again only
+ * replaces the config.
+ */
+export const initPush = next => {
+  const first = config === null;
+  config = next;
+  if (!first) {
+    return;
+  }
+  const mods = resolveModules();
+  if (!mods) {
+    setState({
+      status: 'unavailable'
+    });
+    return;
+  }
+  const m = mods.notifications;
+  m.setNotificationHandler({
+    handleNotification: async () => {
+      const show = config?.showInForeground?.() ?? true;
+      return {
+        shouldShowBanner: show,
+        shouldShowList: show,
+        shouldPlaySound: show,
+        shouldSetBadge: true
+      };
+    }
+  });
+  if (Platform.OS === 'android' && next.androidChannels?.length) {
+    channelsReady = createChannels(m, next.androidChannels);
+  }
+  m.addNotificationResponseReceivedListener(handleResponse);
+  void m.getLastNotificationResponseAsync().then(response => {
+    handleResponse(response);
+    return m.clearLastNotificationResponseAsync?.();
+  }).catch(error => Logger.error('[push] reading the launch notification failed', error));
+  void m.getPermissionsAsync().then(response => setState({
+    status: toPermissionStatus(response)
+  })).catch(error => Logger.error('[push] permission check failed', error));
+};
+
+/**
+ * Asks for permission, reads the native device token and registers it through
+ * `config.register`, then re-registers whenever the OS rotates the token.
+ */
+export const enablePush = async () => {
+  requireConfig();
+  const mods = resolveModules();
+  if (!mods) {
+    setState({
+      status: 'unavailable'
+    });
+    return 'unavailable';
+  }
+  const m = mods.notifications;
+
+  // Android 13 shows the permission prompt only once a channel exists.
+  await channelsReady;
+  let permission = await m.getPermissionsAsync();
+  if (!permission.granted) {
+    permission = await m.requestPermissionsAsync();
+  }
+  if (!permission.granted) {
+    setState({
+      status: 'denied'
+    });
+    return 'denied';
+  }
+  const device = await toDevice(await m.getDevicePushTokenAsync(), mods.applicationId);
+  if (!device) {
+    setState({
+      status: 'unavailable'
+    });
+    return 'unavailable';
+  }
+  await requireConfig().register(device);
+  tokenSubscription?.remove();
+  tokenSubscription = m.addPushTokenListener(token => {
+    void toDevice(token, mods.applicationId).then(next => next ? requireConfig().register(next) : undefined).catch(error => Logger.error('[push] re-registering a new token failed', error));
+  });
+  setState({
+    status: 'granted',
+    enabled: true
+  });
+  return 'granted';
+};
+
+/**
+ * Unregisters the device through `config.unregister` and stops following token
+ * changes. Taps on notifications already delivered still reach `onOpen`.
+ */
+export const disablePush = async () => {
+  const current = requireConfig();
+  await current.unregister(await current.getInstallationId());
+  tokenSubscription?.remove();
+  tokenSubscription = null;
+  setState({
+    enabled: false
+  });
+};
+
+/** Sets the app icon badge; a no-op where push is unavailable or the launcher has no badge. */
+export const setBadgeCount = async count => {
+  const mods = resolveModules();
+  if (!mods) {
+    return;
+  }
+  await mods.notifications.setBadgeCountAsync(count);
+};
+const subscribe = notify => {
+  subscribers.add(notify);
+  return () => {
+    subscribers.delete(notify);
+  };
+};
+const getSnapshot = () => state;
+const enable = async () => {
+  await enablePush();
+};
+
+/** Push status for a settings switch, re-rendering when it changes. */
+export const usePush = () => {
+  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return {
+    ...snapshot,
+    enable,
+    disable: disablePush
+  };
+};
+//# sourceMappingURL=push.js.map

package/lib/typescript/commonjs/push/index.d.ts

@@ -0,0 +1,3 @@
+export type { PushAndroidChannel, PushConfig, PushDevice, PushModules, PushNotificationsLike, PushPlatform, PushState, PushStatus } from './push';
+export { disablePush, enablePush, initPush, setBadgeCount, setPushImplementation, usePush } from './push';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/push/push.d.ts

@@ -0,0 +1,117 @@
+export type PushPlatform = 'Fcm' | 'Apns';
+export interface PushDevice {
+    installationId: string;
+    platform: PushPlatform;
+    token: string;
+    /** The app's bundle id, the APNs topic on iOS. */
+    appId: string;
+}
+export interface PushAndroidChannel {
+    id: string;
+    name: string;
+    importance?: 'default' | 'high';
+}
+export interface PushConfig {
+    getInstallationId: () => Promise<string> | string;
+    /** Sends the device to the app's own API. */
+    register: (device: PushDevice) => Promise<void>;
+    /** Removes the device from the app's own API. */
+    unregister: (installationId: string) => Promise<void>;
+    /** A notification was tapped, including the tap that launched the app. */
+    onOpen: (data: Record<string, string>) => void;
+    /** Only for channels the app does not create natively. */
+    androidChannels?: PushAndroidChannel[];
+    /** Whether a notification arriving while the app is open is shown. Defaults to true. */
+    showInForeground?: () => boolean;
+}
+export type PushStatus = 'unknown' | 'granted' | 'denied' | 'unavailable';
+export interface PushState {
+    status: PushStatus;
+    /** True once this process has registered the device, false after `disablePush`. */
+    enabled: boolean;
+}
+interface PermissionResponseLike {
+    status: 'granted' | 'denied' | 'undetermined';
+    granted: boolean;
+}
+interface SubscriptionLike {
+    remove: () => void;
+}
+interface NotificationResponseLike {
+    actionIdentifier: string;
+    notification: {
+        request: {
+            identifier: string;
+            content: {
+                data?: Record<string, unknown> | null;
+            };
+        };
+    };
+}
+interface DevicePushTokenLike {
+    type: string;
+    data: unknown;
+}
+/** The slice of expo-notifications this module calls, so the optional peer stays untyped at build. */
+export interface PushNotificationsLike {
+    getPermissionsAsync: () => Promise<PermissionResponseLike>;
+    requestPermissionsAsync: () => Promise<PermissionResponseLike>;
+    getDevicePushTokenAsync: () => Promise<DevicePushTokenLike>;
+    addPushTokenListener: (listener: (token: DevicePushTokenLike) => void) => SubscriptionLike;
+    addNotificationResponseReceivedListener: (listener: (response: NotificationResponseLike) => void) => SubscriptionLike;
+    getLastNotificationResponseAsync: () => Promise<NotificationResponseLike | null>;
+    clearLastNotificationResponseAsync?: () => Promise<void>;
+    setNotificationHandler: (handler: {
+        handleNotification: () => Promise<{
+            shouldShowBanner: boolean;
+            shouldShowList: boolean;
+            shouldPlaySound: boolean;
+            shouldSetBadge: boolean;
+        }>;
+    } | null) => void;
+    setNotificationChannelAsync: (id: string, channel: {
+        name: string;
+        importance: number;
+    }) => Promise<unknown>;
+    setBadgeCountAsync: (count: number) => Promise<boolean>;
+    AndroidImportance: {
+        DEFAULT: number;
+        HIGH: number;
+    };
+}
+export interface PushModules {
+    notifications: PushNotificationsLike;
+    /** The bundle id, from expo-application. */
+    applicationId: string | null;
+}
+/**
+ * Replace the native modules. For tests and the showcase, to reach paths a
+ * real device never takes; an injected backend is taken on trust, Expo Go
+ * included. Pass `null` to restore expo-notifications.
+ */
+export declare const setPushImplementation: (impl: PushModules | null) => void;
+/**
+ * Wires push at startup: the foreground handler, Android channels, and tap
+ * handling, including the tap that launched the app. Calling it again only
+ * replaces the config.
+ */
+export declare const initPush: (next: PushConfig) => void;
+/**
+ * Asks for permission, reads the native device token and registers it through
+ * `config.register`, then re-registers whenever the OS rotates the token.
+ */
+export declare const enablePush: () => Promise<"granted" | "denied" | "unavailable">;
+/**
+ * Unregisters the device through `config.unregister` and stops following token
+ * changes. Taps on notifications already delivered still reach `onOpen`.
+ */
+export declare const disablePush: () => Promise<void>;
+/** Sets the app icon badge; a no-op where push is unavailable or the launcher has no badge. */
+export declare const setBadgeCount: (count: number) => Promise<void>;
+/** Push status for a settings switch, re-rendering when it changes. */
+export declare const usePush: () => PushState & {
+    enable: () => Promise<void>;
+    disable: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=push.d.ts.map

package/lib/typescript/module/push/index.d.ts

@@ -0,0 +1,3 @@
+export type { PushAndroidChannel, PushConfig, PushDevice, PushModules, PushNotificationsLike, PushPlatform, PushState, PushStatus } from './push.js';
+export { disablePush, enablePush, initPush, setBadgeCount, setPushImplementation, usePush } from './push.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/push/push.d.ts

@@ -0,0 +1,117 @@
+export type PushPlatform = 'Fcm' | 'Apns';
+export interface PushDevice {
+    installationId: string;
+    platform: PushPlatform;
+    token: string;
+    /** The app's bundle id, the APNs topic on iOS. */
+    appId: string;
+}
+export interface PushAndroidChannel {
+    id: string;
+    name: string;
+    importance?: 'default' | 'high';
+}
+export interface PushConfig {
+    getInstallationId: () => Promise<string> | string;
+    /** Sends the device to the app's own API. */
+    register: (device: PushDevice) => Promise<void>;
+    /** Removes the device from the app's own API. */
+    unregister: (installationId: string) => Promise<void>;
+    /** A notification was tapped, including the tap that launched the app. */
+    onOpen: (data: Record<string, string>) => void;
+    /** Only for channels the app does not create natively. */
+    androidChannels?: PushAndroidChannel[];
+    /** Whether a notification arriving while the app is open is shown. Defaults to true. */
+    showInForeground?: () => boolean;
+}
+export type PushStatus = 'unknown' | 'granted' | 'denied' | 'unavailable';
+export interface PushState {
+    status: PushStatus;
+    /** True once this process has registered the device, false after `disablePush`. */
+    enabled: boolean;
+}
+interface PermissionResponseLike {
+    status: 'granted' | 'denied' | 'undetermined';
+    granted: boolean;
+}
+interface SubscriptionLike {
+    remove: () => void;
+}
+interface NotificationResponseLike {
+    actionIdentifier: string;
+    notification: {
+        request: {
+            identifier: string;
+            content: {
+                data?: Record<string, unknown> | null;
+            };
+        };
+    };
+}
+interface DevicePushTokenLike {
+    type: string;
+    data: unknown;
+}
+/** The slice of expo-notifications this module calls, so the optional peer stays untyped at build. */
+export interface PushNotificationsLike {
+    getPermissionsAsync: () => Promise<PermissionResponseLike>;
+    requestPermissionsAsync: () => Promise<PermissionResponseLike>;
+    getDevicePushTokenAsync: () => Promise<DevicePushTokenLike>;
+    addPushTokenListener: (listener: (token: DevicePushTokenLike) => void) => SubscriptionLike;
+    addNotificationResponseReceivedListener: (listener: (response: NotificationResponseLike) => void) => SubscriptionLike;
+    getLastNotificationResponseAsync: () => Promise<NotificationResponseLike | null>;
+    clearLastNotificationResponseAsync?: () => Promise<void>;
+    setNotificationHandler: (handler: {
+        handleNotification: () => Promise<{
+            shouldShowBanner: boolean;
+            shouldShowList: boolean;
+            shouldPlaySound: boolean;
+            shouldSetBadge: boolean;
+        }>;
+    } | null) => void;
+    setNotificationChannelAsync: (id: string, channel: {
+        name: string;
+        importance: number;
+    }) => Promise<unknown>;
+    setBadgeCountAsync: (count: number) => Promise<boolean>;
+    AndroidImportance: {
+        DEFAULT: number;
+        HIGH: number;
+    };
+}
+export interface PushModules {
+    notifications: PushNotificationsLike;
+    /** The bundle id, from expo-application. */
+    applicationId: string | null;
+}
+/**
+ * Replace the native modules. For tests and the showcase, to reach paths a
+ * real device never takes; an injected backend is taken on trust, Expo Go
+ * included. Pass `null` to restore expo-notifications.
+ */
+export declare const setPushImplementation: (impl: PushModules | null) => void;
+/**
+ * Wires push at startup: the foreground handler, Android channels, and tap
+ * handling, including the tap that launched the app. Calling it again only
+ * replaces the config.
+ */
+export declare const initPush: (next: PushConfig) => void;
+/**
+ * Asks for permission, reads the native device token and registers it through
+ * `config.register`, then re-registers whenever the OS rotates the token.
+ */
+export declare const enablePush: () => Promise<"granted" | "denied" | "unavailable">;
+/**
+ * Unregisters the device through `config.unregister` and stops following token
+ * changes. Taps on notifications already delivered still reach `onOpen`.
+ */
+export declare const disablePush: () => Promise<void>;
+/** Sets the app icon badge; a no-op where push is unavailable or the launcher has no badge. */
+export declare const setBadgeCount: (count: number) => Promise<void>;
+/** Push status for a settings switch, re-rendering when it changes. */
+export declare const usePush: () => PushState & {
+    enable: () => Promise<void>;
+    disable: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=push.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webority/mobile-core",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Platform layer for Webority React Native apps: HTTP clients, auth/token storage, config, logging, formatters, validators, network status, permissions, storage and version checks. No UI.",
   "keywords": [
     "react-native",
@@ -161,6 +161,16 @@
         "default": "./lib/commonjs/share/index.js"
       }
     },
+    "./push": {
+      "import": {
+        "types": "./lib/typescript/module/push/index.d.ts",
+        "default": "./lib/module/push/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/push/index.d.ts",
+        "default": "./lib/commonjs/push/index.js"
+      }
+    },
     "./smsRetriever": {
       "import": {
         "types": "./lib/typescript/module/smsRetriever/index.d.ts",