@robono/messaging-react-native 0.2.0 → 0.3.1

package/dist/expo-notifications.js

@@ -0,0 +1,92 @@
+import * as Notifications from 'expo-notifications';
+import * as Crypto from 'expo-crypto';
+import * as SecureStore from 'expo-secure-store';
+import { Platform } from 'react-native';
+import { createMessagingNotificationRouter, parseMessagingNotification } from '@robono/messaging';
+/** One restored account. Never prompts on mount, replaces a global handler or handles calling pushes. */
+export async function connectExpoMessagingNotifications(options) {
+    if (!['ios', 'android'].includes(Platform.OS))
+        throw Error('Mobile notification registration requires iPhone or Android.');
+    const endpoint = new URL(options.url);
+    if (endpoint.protocol !== 'https:' || endpoint.username || endpoint.password)
+        throw Error('Use your authenticated HTTPS notification endpoint.');
+    let disposed = false, closing = false, registerQueue = Promise.resolve(), accountScope;
+    const key = 'robono.messaging.device.' + await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, endpoint.origin + endpoint.pathname);
+    let deviceId = await SecureStore.getItemAsync(key);
+    if (!deviceId) {
+        deviceId = Crypto.randomUUID();
+        await SecureStore.setItemAsync(key, deviceId);
+    }
+    async function request(input) {
+        const token = await options.getAccessToken();
+        if (disposed)
+            throw Error('Notification session has ended.');
+        const response = await (options.fetch ?? fetch)(endpoint.href, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(15000), headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' }, body: JSON.stringify({ ...input, ...(accountScope ? { accountScope } : {}) }) });
+        const data = await response.json();
+        if (!response.ok)
+            throw Error(data?.error?.message ?? 'Notification setup is unavailable. Check your app’s Apple/Google credentials.');
+        return data;
+    }
+    const status = await request({ operation: 'notification-status' });
+    if (status.userId !== options.userId || typeof status.accountScope !== 'string' || !/^[a-f\d]{64}$/.test(status.accountScope))
+        throw Error('The notification session does not match the signed-in account.');
+    accountScope = status.accountScope;
+    const router = createMessagingNotificationRouter({ accountScope: status.accountScope, authorize: options.authorize, open: options.open, refresh: options.refresh });
+    const register = (token) => {
+        const work = registerQueue.then(async () => {
+            if (disposed || closing)
+                return;
+            const data = await request({ operation: 'register-device', deviceId, provider: Platform.OS === 'ios' ? 'apns' : 'fcm', token: String(token.data) });
+            if (data.accountScope !== status.accountScope)
+                throw Error('The signed-in account changed. Reconnect notifications for the new account.');
+        });
+        registerQueue = work.catch(() => { });
+        return work;
+    };
+    const tokenListener = Notifications.addPushTokenListener(token => { void register(token).catch(options.onError); });
+    const received = Notifications.addNotificationReceivedListener(notification => { void router.handle(notification.request.content.data).catch(options.onError); });
+    const response = async (value) => {
+        if (disposed || closing || !value || value.actionIdentifier !== Notifications.DEFAULT_ACTION_IDENTIFIER)
+            return;
+        if (await router.handle(value.notification.request.content.data, true)) {
+            const last = await Notifications.getLastNotificationResponseAsync();
+            if (!disposed && last?.notification.request.identifier === value.notification.request.identifier)
+                await Notifications.clearLastNotificationResponseAsync();
+        }
+    };
+    const opened = Notifications.addNotificationResponseReceivedListener(value => { void response(value).catch(options.onError); });
+    const ready = (async () => {
+        if (Platform.OS === 'android')
+            await Notifications.setNotificationChannelAsync('robono-messages', { name: 'Messages', importance: Notifications.AndroidImportance.HIGH });
+        if ((await Notifications.getPermissionsAsync()).granted)
+            await register(await Notifications.getDevicePushTokenAsync());
+        await response(await Notifications.getLastNotificationResponseAsync());
+    })();
+    void ready.catch(options.onError);
+    const dispose = () => { disposed = true; router.dispose(); tokenListener.remove(); received.remove(); opened.remove(); };
+    return {
+        ready,
+        /** Call only after the user chooses Enable notifications in your interface. */
+        async enable() { if (disposed || closing)
+            return false; const permission = await Notifications.requestPermissionsAsync(); if (!permission.granted)
+            return false; await register(await Notifications.getDevicePushTokenAsync()); return true; },
+        /** Await before revoking your login session, so the old account's token is removed. */
+        async signOut() { closing = true; router.dispose(); try {
+            await registerQueue;
+            await request({ operation: 'remove-device', deviceId });
+        }
+        finally {
+            dispose();
+        } },
+        dispose,
+    };
+}
+/** Compose with the host's existing handler. Suppress only this account's open conversation. */
+export function withMessagingNotificationPresentation(handler, current) {
+    return { ...handler, handleNotification: async (notification) => {
+            const event = parseMessagingNotification(notification.request.content.data), active = current();
+            if (event && (event.accountScope !== active.accountScope || event.conversationId === active.conversationId))
+                return { shouldPlaySound: false, shouldSetBadge: false, shouldShowBanner: false, shouldShowList: false };
+            return handler.handleNotification(notification);
+        } };
+}

package/dist/expo-outbox.js

@@ -2,6 +2,7 @@ import * as FS from 'expo-file-system/legacy';
 import * as Crypto from 'expo-crypto';
 import { MessagingClient, createMessagingTransport } from '@robono/messaging';
 import { NativeMessagingOutbox, emptyNativeDraft } from './native-outbox.js';
+import { createExpoMessagingHistory } from './expo-history.js';
 import { ExpoSavedMessages, bindExpoSaved } from './expo-saved.js';
 const stores = new WeakMap();
 export const expoOutbox = (client) => stores.get(client);
@@ -72,7 +73,7 @@ const files = {
 export function createExpoMessagingClient(options) {
     const request = createMessagingTransport(options), store = options.persistence === false ? undefined : new NativeMessagingOutbox(options.url, options.userId, files, options.namespace);
     const saved = store ? new ExpoSavedMessages(options.url, options.userId, options.namespace) : undefined;
-    const client = new MessagingClient({ request, userId: options.userId, createMessageId: Crypto.randomUUID, outbox: store, saved, transformRequest: options.transformRequest });
+    const client = new MessagingClient({ request, userId: options.userId, createMessageId: Crypto.randomUUID, outbox: store, saved, historyCache: store ? createExpoMessagingHistory(options.url, options.userId, options.namespace) : undefined, transformRequest: options.transformRequest });
     if (store)
         stores.set(client, store);
     if (saved)

package/dist/expo-privacy.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { type PrivacyLayerProps } from './extras.js';
+/** Optional Expo adapter; install expo-blur in the customer app. */
+export declare function ExpoMessagingPrivacyLayer({ children, enabled, background }: PrivacyLayerProps): React.JSX.Element;

package/dist/expo-privacy.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef } from 'react';
+import { View } from 'react-native';
+import { BlurView, BlurTargetView } from 'expo-blur';
+import { privacyReadingStripHeight } from './extras.js';
+/** Optional Expo adapter; install expo-blur in the customer app. */
+export function ExpoMessagingPrivacyLayer({ children, enabled, background }) { const target = useRef(null); return _jsxs(View, { style: { flex: 1, minHeight: 0, overflow: 'hidden' }, children: [_jsx(BlurTargetView, { ref: target, style: { flex: 1, minHeight: 0 }, children: children }), enabled && _jsx(BlurView, { pointerEvents: "none", testID: "privacy-lens-mask", blurTarget: target, blurMethod: "dimezisBlurView", intensity: 50, tint: background.toLowerCase() === "#ffffff" ? "light" : "dark", style: { position: 'absolute', left: 0, right: 0, top: 0, bottom: privacyReadingStripHeight } })] }); }

package/dist/expo-screen.d.ts

@@ -0,0 +1,42 @@
+export { createExpoMessagingClient } from './expo-outbox.js';
+import React from 'react';
+import { type MessagingAppearance } from '@robono/messaging';
+import { type MessagingScreenProps } from './index.js';
+import { MessagingMediaController, type LocalMessagingMedia, type MessagingMediaStorage } from './media-controller.js';
+import { type MediaReadyStage } from './media-readiness.js';
+import { type MessagingAudioSession } from './expo-media.js';
+export { createExpoMessagingAudioSession, createExpoMessagingDevice, createExpoMessagingStorage } from './expo-media.js';
+export type { MessagingAudioSession } from './expo-media.js';
+export type { LocalMessagingMedia, MessagingMediaStorage, MediaTransferOptions } from './media-controller.js';
+export { MessagingMediaController } from './media-controller.js';
+export declare function MessagingMediaOverlay({ controller, audio, appearance, inlineVoice, inlineRecorder, viewerActions, onDismiss }: {
+    onDismiss?: () => void;
+    viewerActions?: () => {
+        onForward?: () => void;
+        onDelete?: () => void;
+    };
+    controller: MessagingMediaController;
+    audio: MessagingAudioSession;
+    appearance: MessagingAppearance;
+    inlineVoice?: boolean | (() => boolean);
+    inlineRecorder?: boolean | (() => boolean);
+}): React.JSX.Element | null;
+export interface ExpoMessagingScreenProps extends Omit<MessagingScreenProps, 'pickAttachment' | 'openAttachment'> {
+    storage: MessagingMediaStorage;
+    audioSession: MessagingAudioSession;
+    /** Optional timing callback from native image/frame/playback readiness, measured from opening. */
+    onMediaReady?: (event: {
+        messageId: string;
+        kind: string;
+        stage: MediaReadyStage;
+        elapsedMs: number;
+    }) => void;
+    /** Preload a bounded set of small recent attachments while this conversation is open. Default true. */
+    preloadRecentMedia?: boolean;
+    /** Compose a conversation with the supplied media adapters. */
+    renderConversation?: (props: MessagingScreenProps) => React.ReactNode;
+    /** Resolve an authorized recent attachment to an adapter-owned cache copy, never a library original. */
+    resolveAttachmentChoice?: (id: string, signal: AbortSignal) => Promise<LocalMessagingMedia | null>;
+}
+/** Optional ready-made recording, preview, upload and download tools for both mobile platforms. */
+export declare function ExpoMessagingScreen({ storage, audioSession, renderConversation, preloadRecentMedia, ...props }: ExpoMessagingScreenProps): React.JSX.Element;