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

package/dist/expo-thumbnails.js

@@ -0,0 +1,68 @@
+import * as ImageManipulator from 'expo-image-manipulator';
+import * as VideoThumbnails from 'expo-video-thumbnails';
+import * as FS from 'expo-file-system/legacy';
+/** Small local previews, with bounded downloads and memory. Large originals stay
+ * tap-to-open until the storage service supplies a dedicated thumbnail. */
+export function createExpoThumbnails(storage, local, remove) {
+    let generation = 0;
+    const cache = new Map(), abort = new Set();
+    let queue = Promise.resolve();
+    function clear() { generation++; cache.clear(); for (const c of abort)
+        c.abort(); abort.clear(); }
+    function preview(message) {
+        const media = message.media;
+        if (!media || message.deleted)
+            return Promise.resolve({});
+        if (message.kind === 'voice')
+            return Promise.resolve({ waveform: media.waveform });
+        if (!['image', 'video'].includes(message.kind))
+            return Promise.resolve({});
+        const id = media.assetId, existing = cache.get(id);
+        if (existing)
+            return existing;
+        const g = generation;
+        const work = queue.then(async () => {
+            if (g !== generation)
+                return {};
+            let file = local(id), downloaded = false, poster, thumbnail;
+            const controller = new AbortController();
+            abort.add(controller);
+            try {
+                let dedicated = false;
+                if (!file && storage.thumbnail) {
+                    file = await storage.thumbnail(message, { signal: controller.signal, onProgress: () => { } }).catch(() => null) ?? undefined;
+                    dedicated = !!file;
+                    downloaded = !!file;
+                }
+                if (!file) {
+                    if (media.byteSize > 2 * 1024 * 1024)
+                        return {};
+                    file = await storage.download(message, { signal: controller.signal, onProgress: () => { } });
+                    downloaded = true;
+                }
+                if (g !== generation)
+                    return {};
+                if (message.kind === 'video' && !dedicated)
+                    poster = (await VideoThumbnails.getThumbnailAsync(file.uri, { time: 0, quality: .6 })).uri;
+                const result = await ImageManipulator.manipulateAsync(poster ?? file.uri, [{ resize: { width: 480 } }], { compress: .7, format: ImageManipulator.SaveFormat.JPEG, base64: true });
+                thumbnail = result.uri;
+                return g === generation && result.base64 ? { uri: 'data:image/jpeg;base64,' + result.base64 } : {};
+            }
+            finally {
+                abort.delete(controller);
+                if (downloaded && file)
+                    await remove(file).catch(() => { });
+                for (const uri of [poster, thumbnail])
+                    if (uri && FS.cacheDirectory && uri.startsWith(FS.cacheDirectory))
+                        await FS.deleteAsync(uri, { idempotent: true }).catch(() => { });
+            }
+        }).catch(() => ({}));
+        queue = work.then(() => { });
+        cache.set(id, work);
+        if (cache.size > 100)
+            cache.delete(cache.keys().next().value);
+        return work;
+    }
+    return { preview, clear, alias: (from, to) => { const value = cache.get(from); if (value)
+            cache.set(to, value); } };
+}

package/dist/expo.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;