@robono/messaging-react-native 0.0.0-stage → 0.2.0

package/app.plugin.cjs

@@ -0,0 +1,5 @@
+const {withDangerousMod,createRunOncePlugin} = require('expo/config-plugins');
+module.exports=createRunOncePlugin(config=>withDangerousMod(config,['ios',async value=>{
+  require('./plugin/preserve-call-audio.cjs').install(value.modRequest.projectRoot);
+  return value;
+}]),'@robono/messaging-react-native',require('./package.json').version);

package/dist/call-message.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+/** A new, reviewed message after no answer. Never records or sends a call automatically. */
+export declare function UnansweredCallMessage({ callId, onDismiss }: {
+    callId: string;
+    onDismiss: () => void;
+}): React.JSX.Element | null;

package/dist/call-message.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Pressable, Text, View } from 'react-native';
+import { useMessagingUI } from './index.js';
+/** A new, reviewed message after no answer. Never records or sends a call automatically. */
+export function UnansweredCallMessage({ callId, onDismiss }) {
+    const { client, design, state, pickAttachment, releaseAttachment, components } = useMessagingUI();
+    const [option, setOption] = useState(null);
+    const [draft, setDraft] = useState(null);
+    const [busy, setBusy] = useState(false), [error, setError] = useState(''), [attempt, setAttempt] = useState(0);
+    const generation = useRef(0), inFlight = useRef(false), prepared = useRef(null);
+    const release = useRef(releaseAttachment);
+    release.current = releaseAttachment;
+    function clearDraft() {
+        const media = prepared.current;
+        prepared.current = null;
+        setDraft(null);
+        if (media)
+            void release.current?.(media);
+    }
+    useEffect(() => {
+        const id = ++generation.current;
+        clearDraft();
+        setOption(null);
+        setError('');
+        setBusy(false);
+        void client.unansweredCall(callId).then(o => { if (id === generation.current)
+            setOption(o); })
+            .catch(() => { if (id === generation.current)
+            setError('Could not check message availability.'); });
+        return () => { generation.current++; const media = prepared.current; prepared.current = null; if (media)
+            void release.current?.(media); };
+    }, [client, callId, state.conversationId, attempt]);
+    async function record() {
+        if (inFlight.current || !option || !pickAttachment)
+            return;
+        const id = generation.current, conversation = state.conversationId;
+        inFlight.current = true;
+        setBusy(true);
+        setError('');
+        try {
+            const current = await client.unansweredCall(callId);
+            if (id !== generation.current)
+                return;
+            if (!current || current.kind !== option.kind) {
+                clearDraft();
+                setOption(current);
+                return;
+            }
+            const media = await pickAttachment(current.kind, { maxDurationMs: current.maxDurationMs, ...(current.kind === 'video' ? { source: 'call-video' } : {}), intent: 'attach' });
+            if (!media)
+                return;
+            if (id !== generation.current || client.getSnapshot().conversationId !== conversation) {
+                void release.current?.(media);
+                return;
+            }
+            clearDraft();
+            prepared.current = media;
+            setDraft({ kind: current.kind, media });
+        }
+        catch {
+            if (id === generation.current)
+                setError('Could not prepare your message. Try again.');
+        }
+        finally {
+            inFlight.current = false;
+            if (id === generation.current)
+                setBusy(false);
+        }
+    }
+    async function send() {
+        if (inFlight.current || !draft)
+            return;
+        inFlight.current = true;
+        setBusy(true);
+        setError('');
+        const id = generation.current;
+        try {
+            const current = await client.unansweredCall(callId);
+            if (id !== generation.current)
+                return;
+            if (!current || current.kind !== draft.kind) {
+                clearDraft();
+                setOption(current);
+                return;
+            }
+            // The client now owns the stable retry identity. Unmounting only releases
+            // local preview resources, never the uploaded asset needed by a retry.
+            const work = client.send({ kind: draft.kind, media: draft.media, unansweredCallId: callId });
+            clearDraft();
+            onDismiss();
+            await work;
+        }
+        catch {
+            if (id === generation.current)
+                setError('The message could not be sent. Check the conversation for a retry.');
+        }
+        finally {
+            inFlight.current = false;
+            if (id === generation.current)
+                setBusy(false);
+        }
+    }
+    if (!pickAttachment || !state.settings?.enabled || state.conversation?.canSend === false || (!option && !error))
+        return null;
+    const c = design.colors, VoiceAttachment = components?.VoiceAttachment;
+    const action = (label, onPress) => _jsx(Pressable, { accessibilityRole: "button", disabled: busy, onPress: onPress, style: { paddingVertical: 12, paddingHorizontal: 4, minHeight: 44 }, children: _jsx(Text, { style: { color: c.incomingText, fontWeight: '600' }, children: label }) });
+    return _jsxs(View, { style: { backgroundColor: c.incoming, padding: 16, borderTopWidth: 1, borderTopColor: c.secondary + '30', gap: 6 }, children: [_jsx(Text, { style: { color: c.incomingText, fontSize: 16, fontWeight: '600' }, children: "No answer" }), option && _jsx(Text, { style: { color: c.incomingText, fontSize: 14 }, children: draft ? 'Review your message, then send it.' : `Leave a ${option.kind === 'voice' ? 'voice' : 'video'} message in this chat.` }), draft && _jsx(View, { children: draft.kind === 'voice' && VoiceAttachment ? _jsx(VoiceAttachment, { media: draft.media, appearance: design, disabled: busy, onRemove: clearDraft }) : _jsxs(Text, { style: { color: c.incomingText }, children: [draft.kind === 'voice' ? 'Voice' : 'Video', " message ready"] }) }), _jsxs(View, { style: { flexDirection: 'row', gap: 16, flexWrap: 'wrap' }, children: [option && (draft ? action('Send message', () => void send()) : action(`Record ${option.kind === 'voice' ? 'voice' : 'video'} message`, () => void record())), !option && error && action('Try again', () => setAttempt(value => value + 1)), action('Not now', () => { clearDraft(); onDismiss(); })] }), !!error && _jsx(Text, { accessibilityRole: "alert", style: { color: c.incomingText }, children: error })] });
+}

package/dist/calling.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type MessagingScreenProps } from './index.js';
+export { UnansweredCallMessage } from './call-message.js';
+/** Optional call entry in the standard message header. The host controls eligibility and admission. */
+export declare function MessagingCallHeader(): React.JSX.Element;
+export interface MessagingCallingScreenProps extends MessagingScreenProps {
+    /** Supply only when this contact is eligible. Never bypass server-side permissions. */
+    onCall?: () => void;
+    callLabel?: string;
+    onVideoCall?: () => void;
+    videoCallLabel?: string;
+    unansweredCallId?: string;
+    onDismissCallMessage?: () => void;
+}
+export declare function MessagingCallingScreen({ onCall, onVideoCall, videoCallLabel, callLabel, components, unansweredCallId, onDismissCallMessage, ...props }: MessagingCallingScreenProps): React.JSX.Element;

package/dist/calling.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useSyncExternalStore } from 'react';
+import { Pressable, View, Text } from 'react-native';
+import { RobonoIcon } from './visual/RobonoIcon.js';
+import { messagingHeaderColors, MessagingScreen, MessagingProvider, MessagingHeader, MessagingComposer, useMessagingUI } from './index.js';
+import { UnansweredCallMessage } from './call-message.js';
+export { UnansweredCallMessage } from './call-message.js';
+const Action = createContext(null);
+const FollowUp = createContext(null);
+function CallingMessageComposer() { const follow = useContext(FollowUp); return _jsxs(_Fragment, { children: [follow && _jsx(UnansweredCallMessage, { callId: follow.callId, onDismiss: follow.dismiss }), _jsx(MessagingComposer, {})] }); }
+/** Optional call entry in the standard message header. The host controls eligibility and admission. */
+export function MessagingCallHeader() {
+    const action = useContext(Action), { design, state } = useMessagingUI();
+    const allowed = state.conversation?.canSend !== false;
+    return _jsxs(MessagingHeader, { children: [allowed && action?.onCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.label, onPress: action.onCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "phone", size: 24, color: messagingHeaderColors(design, state.conversation?.kind === 'group').foreground }) }), allowed && action?.onVideoCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.videoLabel, onPress: action.onVideoCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "video", size: 24, color: messagingHeaderColors(design, state.conversation?.kind === 'group').foreground }) })] });
+}
+export function MessagingCallingScreen({ onCall, onVideoCall, videoCallLabel = 'Video call', callLabel = 'Voice call', components, unansweredCallId, onDismissCallMessage, ...props }) {
+    const state = useSyncExternalStore(props.client.subscribe, props.client.getSnapshot, props.client.getSnapshot);
+    const design = props.appearance ?? state.settings?.appearance;
+    const callingOnly = (onCall || onVideoCall) && design && state.settings && !state.settings.enabled;
+    return _jsx(Action.Provider, { value: onCall || onVideoCall ? { onCall, onVideoCall, label: callLabel, videoLabel: videoCallLabel } : null, children: _jsx(FollowUp.Provider, { value: unansweredCallId && onDismissCallMessage ? { callId: unansweredCallId, dismiss: onDismissCallMessage } : null, children: callingOnly ? _jsx(MessagingProvider, { ...props, children: _jsxs(View, { style: [{ flex: 1, backgroundColor: design.colors.background }, props.style], children: [_jsx(MessagingCallHeader, {}), _jsxs(View, { style: { flex: 1, alignItems: 'center', justifyContent: 'center', gap: 24, padding: 24 }, children: [_jsx(Text, { style: { fontSize: 28, fontWeight: '600', color: design.colors.foreground }, children: props.contact.name }), onCall && _jsxs(Pressable, { accessibilityRole: "button", accessibilityLabel: `Start ${callLabel.toLowerCase()}`, onPress: onCall, style: { minHeight: 56, minWidth: 160, borderRadius: 28, backgroundColor: design.colors.incoming, alignItems: 'center', justifyContent: 'center', padding: 16, flexDirection: 'row', gap: 12 }, children: [_jsx(RobonoIcon, { name: "phone", size: 24, color: design.colors.incomingText }), _jsx(Text, { style: { fontSize: 18, color: design.colors.incomingText }, children: callLabel })] }), onVideoCall && _jsxs(Pressable, { accessibilityRole: "button", accessibilityLabel: `Start ${videoCallLabel.toLowerCase()}`, onPress: onVideoCall, style: { minHeight: 56, padding: 16, borderRadius: 28, backgroundColor: design.colors.incoming, flexDirection: 'row', alignItems: 'center', gap: 12 }, children: [_jsx(RobonoIcon, { name: "video", size: 24, color: design.colors.incomingText }), _jsx(Text, { style: { color: design.colors.incomingText, fontSize: 18 }, children: videoCallLabel })] })] })] }) }) : _jsx(MessagingScreen, { ...props, components: { Header: MessagingCallHeader, Composer: CallingMessageComposer, ...components } }) }) });
+}

package/dist/expo-calling.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type ExpoMessagingScreenProps } from './expo.js';
+import { type MessagingCallingScreenProps } from './calling.js';
+export type ExpoMessagingCallingScreenProps = Omit<ExpoMessagingScreenProps, 'renderConversation'> & Pick<MessagingCallingScreenProps, 'onCall' | 'callLabel' | 'onVideoCall' | 'videoCallLabel' | 'unansweredCallId' | 'onDismissCallMessage'>;
+/** Optional composition of the shared conversation, calling entry and native recording/review tools. */
+export declare function ExpoMessagingCallingScreen({ onCall, callLabel, onVideoCall, videoCallLabel, unansweredCallId, onDismissCallMessage, ...props }: ExpoMessagingCallingScreenProps): React.JSX.Element;

package/dist/expo-calling.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ExpoMessagingScreen } from './expo.js';
+import { MessagingCallingScreen } from './calling.js';
+/** Optional composition of the shared conversation, calling entry and native recording/review tools. */
+export function ExpoMessagingCallingScreen({ onCall, callLabel, onVideoCall, videoCallLabel, unansweredCallId, onDismissCallMessage, ...props }) {
+    return _jsx(ExpoMessagingScreen, { ...props, renderConversation: screen => _jsx(MessagingCallingScreen, { ...screen, onCall: onCall, callLabel: callLabel, onVideoCall: onVideoCall, videoCallLabel: videoCallLabel, unansweredCallId: unansweredCallId, onDismissCallMessage: onDismissCallMessage }) });
+}

package/dist/expo-download.d.ts

@@ -0,0 +1,3 @@
+import type { LocalMessagingMedia, MediaKind } from './media-controller.js';
+/** Export an already-authorized viewer copy; never expose its private source URL. */
+export declare function saveMessagingAttachment(file: LocalMessagingMedia, kind: MediaKind): Promise<void>;

package/dist/expo-download.js

@@ -0,0 +1,43 @@
+import { Platform } from 'react-native';
+import * as FS from 'expo-file-system/legacy';
+import * as Sharing from 'expo-sharing';
+import * as MediaLibrary from 'expo-media-library';
+/** Export an already-authorized viewer copy; never expose its private source URL. */
+export async function saveMessagingAttachment(file, kind) {
+    if (kind === 'image' || kind === 'video') {
+        const permission = await MediaLibrary.requestPermissionsAsync(true, [kind === 'image' ? 'photo' : 'video']);
+        if (!permission.granted)
+            throw Error('Allow photo access to save this attachment.');
+        await MediaLibrary.saveToLibraryAsync(file.uri);
+        return;
+    }
+    if (kind !== 'document')
+        throw Error('This attachment cannot be downloaded.');
+    if (Platform.OS !== 'android') {
+        if (!await Sharing.isAvailableAsync())
+            throw Error('File saving is unavailable.');
+        await Sharing.shareAsync(file.uri, { mimeType: file.mimeType, dialogTitle: 'Save ' + file.fileName });
+        return;
+    }
+    const permission = await FS.StorageAccessFramework.requestDirectoryPermissionsAsync();
+    if (!permission.granted)
+        return;
+    const name = file.fileName.split(/[\\/]/).at(-1)?.replace(/[\u0000-\u001f\u007f]/g, '').trim() || 'Attachment';
+    const destination = await FS.StorageAccessFramework.createFileAsync(permission.directoryUri, name, file.mimeType);
+    try {
+        // Bounded chunks avoid keeping an entire large document and its base64 copy in memory.
+        const chunk = 3 * 256 * 1024;
+        for (let position = 0; position < file.byteSize; position += chunk) {
+            const length = Math.min(chunk, file.byteSize - position);
+            const data = await FS.readAsStringAsync(file.uri, { encoding: FS.EncodingType.Base64, position, length });
+            const bytes = data.length * 3 / 4 - (data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0);
+            if (bytes !== length)
+                throw Error('The attachment could not be read completely.');
+            await FS.writeAsStringAsync(destination, data, { encoding: FS.EncodingType.Base64, append: position > 0 });
+        }
+    }
+    catch (error) {
+        await FS.deleteAsync(destination, { idempotent: true }).catch(() => { });
+        throw error;
+    }
+}

package/dist/expo-media.d.ts

@@ -0,0 +1,19 @@
+import { type AudioMode } from 'expo-audio';
+import type { LocalMessagingMedia, MessagingMediaDevice, MessagingMediaStorage } from './media-controller.js';
+export interface MessagingAudioSession {
+    isAvailable?: (purpose?: 'recording' | 'playback') => boolean;
+    acquire(purpose: 'recording' | 'playback'): Promise<() => Promise<void>>;
+}
+/** Pass your app's call-state guard and restore mode, or supply your existing audio-session coordinator. */
+export declare function createExpoMessagingAudioSession(options?: {
+    isCallActive?: () => boolean;
+    restoreMode?: Partial<AudioMode>;
+}): MessagingAudioSession;
+export declare function copyMessagingCache(file: LocalMessagingMedia): Promise<LocalMessagingMedia>;
+export declare function createExpoMessagingDevice(audio: MessagingAudioSession): MessagingMediaDevice;
+/** Private-storage transport. The endpoint is YOUR authenticated backend, never a Robono API key on the phone. */
+export declare function createExpoMessagingStorage(options: {
+    url: string;
+    getAccessToken: () => Promise<string>;
+    streaming?: boolean;
+}): MessagingMediaStorage;