@robono/messaging-react-native 0.1.0 → 0.3.0

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.d.ts

@@ -0,0 +1,13 @@
+import { MessagingClient, type MessagingRequest } from '@robono/messaging';
+import { NativeMessagingOutbox } from './native-outbox.js';
+export declare const expoOutbox: (client: MessagingClient) => NativeMessagingOutbox | undefined;
+/** Ready-made authenticated mobile client with private, per-account outgoing drafts. */
+export declare function createExpoMessagingClient(options: {
+    url: string;
+    userId: string;
+    getAccessToken: () => Promise<string>;
+    fetch?: typeof fetch;
+    persistence?: false;
+    namespace?: string;
+    transformRequest?: MessagingRequest;
+}): MessagingClient;

package/dist/expo-outbox.js

@@ -0,0 +1,82 @@
+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);
+const digest = (value) => Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, value);
+const root = async (scope) => { if (!FS.documentDirectory)
+    throw Error('Private app storage is unavailable.'); return FS.documentDirectory + 'robono-outgoing/' + await digest(scope) + '/'; };
+const folder = async (scope, cid) => (await root(scope)) + await digest(cid) + '/';
+const asset = async (scope, cid, id) => (await folder(scope, cid)) + 'file-' + await digest(id);
+const files = {
+    async read(scope, cid) {
+        const dir = await folder(scope, cid);
+        if (!(await FS.getInfoAsync(dir)).exists)
+            return emptyNativeDraft();
+        const names = (await FS.readDirectoryAsync(dir)).filter(name => /^state-\d+\.json$/.test(name)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5)));
+        for (const name of names) {
+            try {
+                const state = JSON.parse(await FS.readAsStringAsync(dir + name));
+                if (typeof state.draft === 'string' && Array.isArray(state.messages) && state.files && typeof state.files === 'object')
+                    return state;
+            }
+            catch { }
+        }
+        if (names.length)
+            throw Error('Saved messages could not be read. Your files have been kept.');
+        return emptyNativeDraft();
+    },
+    async write(scope, cid, state) {
+        const dir = await folder(scope, cid);
+        await FS.makeDirectoryAsync(dir, { intermediates: true });
+        const names = (await FS.readDirectoryAsync(dir)).filter(name => /^state-\d+\.json$/.test(name)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5)));
+        const sequence = names.length ? Number(names[0].slice(6, -5)) + 1 : 1, temp = dir + 'pending-' + Crypto.randomUUID() + '.tmp';
+        try {
+            await FS.writeAsStringAsync(temp, JSON.stringify(state));
+            await FS.moveAsync({ from: temp, to: dir + 'state-' + sequence + '.json' });
+        }
+        finally {
+            await FS.deleteAsync(temp, { idempotent: true }).catch(() => { });
+        }
+        // Keep the preceding complete snapshot for interrupted writes; no full app copies.
+        await Promise.all(names.slice(1).map(name => FS.deleteAsync(dir + name, { idempotent: true }).catch(() => { })));
+    },
+    async copy(scope, cid, id, source) {
+        if (!source.uri.startsWith('file://') || source.stream)
+            throw Error('Choose a local attachment.');
+        const dir = await folder(scope, cid), target = await asset(scope, cid, id);
+        await FS.makeDirectoryAsync(dir, { intermediates: true });
+        const existing = await FS.getInfoAsync(target);
+        if (existing.exists && !existing.isDirectory && existing.size === source.byteSize)
+            return target;
+        const temporary = target + '-' + Crypto.randomUUID() + '.tmp';
+        try {
+            await FS.copyAsync({ from: source.uri, to: temporary });
+            const info = await FS.getInfoAsync(temporary);
+            if (!info.exists || info.isDirectory || info.size !== source.byteSize)
+                throw Error('The attachment was not saved completely.');
+            await FS.moveAsync({ from: temporary, to: target });
+            return target;
+        }
+        finally {
+            await FS.deleteAsync(temporary, { idempotent: true }).catch(() => { });
+        }
+    },
+    async file(scope, cid, id) { const target = await asset(scope, cid, id); return (await FS.getInfoAsync(target)).exists ? target : null; },
+    async remove(scope, cid, id) { await FS.deleteAsync(await asset(scope, cid, id), { idempotent: true }); },
+    async clear(scope, cid) { await FS.deleteAsync(cid === undefined ? await root(scope) : await folder(scope, cid), { idempotent: true }); },
+};
+/** Ready-made authenticated mobile client with private, per-account outgoing drafts. */
+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, historyCache: store ? createExpoMessagingHistory(options.url, options.userId, options.namespace) : undefined, transformRequest: options.transformRequest });
+    if (store)
+        stores.set(client, store);
+    if (saved)
+        bindExpoSaved(client, saved);
+    return client;
+}

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-saved.d.ts

@@ -0,0 +1,24 @@
+import { type MessagingClient, type MessagingMessage, type MessagingSavedStore, type SavedMessage } from '@robono/messaging';
+import type { LocalMessagingMedia } from './media-controller.js';
+export declare const expoSaved: (client: MessagingClient) => ExpoSavedMessages | undefined;
+export declare const bindExpoSaved: (client: MessagingClient, store: ExpoSavedMessages) => WeakMap<MessagingClient, ExpoSavedMessages>;
+/** Explicit saved copies in the OS-private app directory, never cache/signed URLs. */
+export declare class ExpoSavedMessages implements MessagingSavedStore {
+    private generation;
+    private scope;
+    private download;
+    constructor(endpoint: string, userId: string, namespace?: string);
+    bindDownload(download: NonNullable<ExpoSavedMessages['download']>): () => void;
+    private serial;
+    private directory;
+    private read;
+    private write;
+    list(): Promise<SavedMessage[]>;
+    prepare(message: MessagingMessage): Promise<{
+        commit: (record: SavedMessage) => Promise<void>;
+        discard: () => Promise<void>;
+    }>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    file(record: SavedMessage): Promise<LocalMessagingMedia>;
+}

package/dist/expo-saved.js

@@ -0,0 +1,76 @@
+import * as FS from 'expo-file-system/legacy';
+import * as Crypto from 'expo-crypto';
+import { savedMessageKey } from '@robono/messaging';
+const stores = new WeakMap();
+export const expoSaved = (client) => stores.get(client);
+export const bindExpoSaved = (client, store) => stores.set(client, store);
+const queues = new Map(), epochs = new Map();
+/** Explicit saved copies in the OS-private app directory, never cache/signed URLs. */
+export class ExpoSavedMessages {
+    generation = 0;
+    scope;
+    download;
+    constructor(endpoint, userId, namespace = 'default') { this.scope = JSON.stringify([endpoint, namespace, userId]); }
+    bindDownload(download) { this.download = download; return () => { if (this.download === download)
+        this.download = undefined; }; }
+    serial(work) { const promise = (queues.get(this.scope) ?? Promise.resolve()).catch(() => { }).then(work); queues.set(this.scope, promise); void promise.finally(() => { if (queues.get(this.scope) === promise)
+        queues.delete(this.scope); }).catch(() => { }); return promise; }
+    async directory() { if (!FS.documentDirectory)
+        throw Error('Private app storage is unavailable.'); return FS.documentDirectory + 'robono-saved/' + await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, this.scope) + '/'; }
+    async read() { const dir = await this.directory(); if (!(await FS.getInfoAsync(dir)).exists)
+        return []; const names = (await FS.readDirectoryAsync(dir)).filter(n => /^state-\d+\.json$/.test(n)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5))); for (const name of names) {
+        try {
+            const rows = JSON.parse(await FS.readAsStringAsync(dir + name));
+            if (Array.isArray(rows) && rows.every(r => r.record?.key && (!r.file || /^file-[\da-f-]+$/i.test(r.file))))
+                return rows;
+        }
+        catch { }
+    } if (names.length)
+        throw Error('Saved messages could not be read. Your files have been kept.'); return []; }
+    async write(rows) { const dir = await this.directory(); await FS.makeDirectoryAsync(dir, { intermediates: true }); const names = (await FS.readDirectoryAsync(dir)).filter(n => /^state-\d+\.json$/.test(n)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5))); const sequence = names.length ? Number(names[0].slice(6, -5)) + 1 : 1, temp = dir + 'pending-' + Crypto.randomUUID(); try {
+        await FS.writeAsStringAsync(temp, JSON.stringify(rows));
+        await FS.moveAsync({ from: temp, to: dir + 'state-' + sequence + '.json' });
+    }
+    finally {
+        await FS.deleteAsync(temp, { idempotent: true }).catch(() => { });
+    } await Promise.all(names.map(n => FS.deleteAsync(dir + n, { idempotent: true }).catch(() => { }))); }
+    list() { return this.serial(async () => (await this.read()).map(r => r.record).sort((a, b) => b.savedAt.localeCompare(a.savedAt))); }
+    async prepare(message) {
+        const generation = this.generation, epoch = epochs.get(this.scope) ?? 0;
+        let file, committed = false;
+        const active = () => { if (generation !== this.generation || epoch !== (epochs.get(this.scope) ?? 0))
+            throw Error('The account was signed out.'); };
+        if (message.media) {
+            if (!this.download)
+                throw Error('Open media tools before saving attachments.');
+            const source = await this.download(message);
+            try {
+                active();
+                if (source.file.stream || !source.file.uri.startsWith('file://'))
+                    throw Error('A local attachment is required.');
+                file = 'file-' + Crypto.randomUUID();
+                const dir = await this.directory();
+                await this.serial(async () => { active(); await FS.makeDirectoryAsync(dir, { intermediates: true }); await FS.copyAsync({ from: source.file.uri, to: dir + file }); const info = await FS.getInfoAsync(dir + file); if (!info.exists || info.isDirectory || info.size !== message.media.byteSize)
+                    throw Error('The saved file is incomplete.'); });
+            }
+            catch (error) {
+                if (file)
+                    await FS.deleteAsync((await this.directory()) + file, { idempotent: true }).catch(() => { });
+                throw error;
+            }
+            finally {
+                await source.release();
+            }
+        }
+        return { commit: (record) => this.serial(async () => { active(); if (record.key !== savedMessageKey(message))
+                throw Error('The saved message changed.'); const rows = await this.read(), old = rows.find(r => r.record.key === record.key); active(); await this.write([{ record, file }, ...rows.filter(r => r.record.key !== record.key)]); committed = true; if (old?.file && old.file !== file)
+                await FS.deleteAsync((await this.directory()) + old.file, { idempotent: true }).catch(() => { }); }), discard: async () => { if (file && !committed)
+                await FS.deleteAsync((await this.directory()) + file, { idempotent: true }).catch(() => { }); } };
+    }
+    remove(key) { return this.serial(async () => { const rows = await this.read(), old = rows.find(r => r.record.key === key); await this.write(rows.filter(r => r.record.key !== key)); if (old?.file)
+        await FS.deleteAsync((await this.directory()) + old.file, { idempotent: true }).catch(() => { }); }); }
+    clear() { this.generation++; epochs.set(this.scope, (epochs.get(this.scope) ?? 0) + 1); return this.serial(async () => { await FS.deleteAsync(await this.directory(), { idempotent: true }); }); }
+    file(record) { return this.serial(async () => { const row = (await this.read()).find(r => r.record.key === record.key); if (!row?.file || !row.record.message.media)
+        throw Error('This saved attachment is unavailable.'); const uri = (await this.directory()) + row.file, info = await FS.getInfoAsync(uri); if (!info.exists || info.isDirectory || info.size !== row.record.message.media.byteSize)
+        throw Error('This saved attachment is missing.'); return { ...row.record.message.media, uri }; }); }
+}

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;