@nebula-rn/host-apis 0.0.1

package/dist/NebulaHostPreviewImageModal.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function NebulaHostPreviewImageModal(): React.ReactElement | null;

package/dist/NebulaHostPreviewImageModal.js

@@ -0,0 +1,81 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { ActivityIndicator, StyleSheet, View } from 'react-native';
+import ImageViewer from 'react-native-image-zoom-viewer';
+import { NebulaAPI } from '@nebula-rn/sdk';
+import { createHostApiFailure, createHostApiSuccess } from './hostApiBridge';
+import { previewImageChannel } from './previewImageRuntime';
+import { saveMediaHost } from './coreHostApis';
+import { downloadFileHost } from './taskHosts';
+function PreviewImageLoading() {
+    return (<View style={styles.loadingContainer}>
+      <ActivityIndicator size="large" color="#999"/>
+    </View>);
+}
+function renderPreviewImageLoading() {
+    return <PreviewImageLoading />;
+}
+export default function NebulaHostPreviewImageModal() {
+    const [request, setRequest] = useState(previewImageChannel.getCurrent());
+    const didCloseRef = useRef(false);
+    useEffect(() => {
+        return previewImageChannel.subscribe(nextRequest => {
+            didCloseRef.current = false;
+            setRequest(nextRequest);
+        });
+    }, []);
+    const imageUrls = useMemo(() => request?.urls.map(url => ({ url })) ?? [], [request]);
+    if (!request) {
+        return null;
+    }
+    const initialIndex = request.current
+        ? request.urls.indexOf(request.current)
+        : 0;
+    const index = initialIndex === -1 ? 0 : initialIndex;
+    const close = (result = createHostApiSuccess({
+        dismissed: true,
+    })) => {
+        if (didCloseRef.current) {
+            return;
+        }
+        didCloseRef.current = true;
+        NebulaAPI.dismissHostModal()
+            .catch(() => { })
+            .finally(() => {
+            previewImageChannel.settle(result);
+        });
+    };
+    return (<View style={styles.container}>
+      <ImageViewer imageUrls={imageUrls} index={index} onCancel={() => close()} onClick={() => close()} onSwipeDown={() => close()} enableSwipeDown useNativeDriver loadingRender={renderPreviewImageLoading} onSave={async (uri) => {
+            try {
+                const download = await downloadFileHost({
+                    url: uri,
+                });
+                await saveMediaHost({
+                    url: download.tempFilePath,
+                    type: 'photo',
+                });
+            }
+            catch (error) {
+                close(createHostApiFailure('PREVIEW_IMAGE_SAVE_FAILED', error instanceof Error
+                    ? error.message
+                    : 'previewImage:fail unable to save image'));
+            }
+        }} menuContext={request.showMenu === false
+            ? undefined
+            : {
+                saveToLocal: request.saveMediaText ?? 'Save Image',
+                cancel: request.cancelText ?? 'Cancel',
+            }}/>
+    </View>);
+}
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: '#000',
+    },
+    loadingContainer: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+});

package/dist/NebulaHostScanModal.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function NebulaHostScanModal(): React.ReactElement | null;

package/dist/NebulaHostScanModal.js

@@ -0,0 +1,172 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { Dimensions, Image, PermissionsAndroid, Platform, StatusBar, StyleSheet, TouchableOpacity, View, } from 'react-native';
+import { Camera, useCameraDevice, useCodeScanner, } from 'react-native-vision-camera';
+import { NebulaAPI } from '@nebula-rn/sdk';
+import { scanCodeChannel } from './scanCodeRuntime';
+const { width, height } = Dimensions.get('screen');
+function createFailureResult(code, message) {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function createSuccessResult(code) {
+    return {
+        ok: true,
+        data: {
+            result: code.value,
+            scanType: code.type,
+            rawData: code,
+        },
+    };
+}
+export default function NebulaHostScanModal() {
+    const [request, setRequest] = useState(scanCodeChannel.getCurrent());
+    const [isActive, setIsActive] = useState(true);
+    const [hasPermission, setHasPermission] = useState(Platform.OS !== 'android');
+    const didHandleScanRef = useRef(false);
+    const device = useCameraDevice('back');
+    const scanTypes = (request?.scanTypes ?? [
+        'qr',
+        'ean-13',
+        'code-128',
+    ]);
+    const codeScanner = useCodeScanner({
+        codeTypes: scanTypes,
+        onCodeScanned: codes => {
+            if (!codes[0] || !isActive || didHandleScanRef.current) {
+                return;
+            }
+            didHandleScanRef.current = true;
+            setIsActive(false);
+            closeWithResult(createSuccessResult(codes[0]));
+        },
+    });
+    const closeWithResult = (result) => {
+        NebulaAPI.dismissHostModal()
+            .catch(() => { })
+            .finally(() => {
+            scanCodeChannel.settle(result);
+        });
+    };
+    useEffect(() => {
+        return scanCodeChannel.subscribe(nextRequest => {
+            didHandleScanRef.current = false;
+            setRequest(nextRequest);
+            setIsActive(true);
+            setHasPermission(Platform.OS !== 'android');
+        });
+    }, []);
+    useEffect(() => {
+        if (!request) {
+            return;
+        }
+        return () => {
+            if (didHandleScanRef.current) {
+                return;
+            }
+            didHandleScanRef.current = true;
+            scanCodeChannel.settle(createFailureResult('USER_CANCELLED', 'scanCode:fail cancel'));
+        };
+    }, [request]);
+    useEffect(() => {
+        if (Platform.OS !== 'android' || !request) {
+            return;
+        }
+        let cancelled = false;
+        const requestAndroidPermission = async () => {
+            const granted = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.CAMERA);
+            if (cancelled || didHandleScanRef.current) {
+                return;
+            }
+            if (granted === PermissionsAndroid.RESULTS.GRANTED) {
+                setHasPermission(true);
+                return;
+            }
+            didHandleScanRef.current = true;
+            closeWithResult(createFailureResult('PERMISSION_DENIED', 'scanCode:fail permission denied'));
+        };
+        requestAndroidPermission().catch(() => {
+            if (cancelled || didHandleScanRef.current) {
+                return;
+            }
+            didHandleScanRef.current = true;
+            closeWithResult(createFailureResult('SCAN_FAILED', 'scanCode:fail unable to request camera permission'));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [request]);
+    if (!request) {
+        return null;
+    }
+    if (Platform.OS === 'android' && !hasPermission) {
+        return <View style={styles.container}/>;
+    }
+    if (!device) {
+        return <View style={styles.container}/>;
+    }
+    const safePaddingTop = Platform.OS === 'ios' ? 54 : 20;
+    return (<View style={styles.container}>
+      <StatusBar translucent backgroundColor="transparent" barStyle="light-content"/>
+      <Camera codeScanner={codeScanner} device={device} isActive={isActive} style={StyleSheet.absoluteFill}/>
+
+      <TouchableOpacity style={[styles.closeIcon, { paddingTop: safePaddingTop }]} onPress={() => {
+            if (didHandleScanRef.current) {
+                return;
+            }
+            didHandleScanRef.current = true;
+            closeWithResult(createFailureResult('USER_CANCELLED', 'scanCode:fail cancel'));
+        }}>
+        <Image source={require('./assets/icon_close.png')} style={styles.closeImg}/>
+      </TouchableOpacity>
+
+      {!request.onlyFromCamera ? (<TouchableOpacity style={styles.albumIcon} onPress={() => {
+                if (didHandleScanRef.current) {
+                    return;
+                }
+                didHandleScanRef.current = true;
+                closeWithResult(createFailureResult('UNSUPPORTED_SOURCE', 'scanCode:fail album selection not implemented'));
+            }}>
+          <Image source={require('./assets/icon_pic.png')} style={styles.albumImg}/>
+        </TouchableOpacity>) : null}
+    </View>);
+}
+const styles = StyleSheet.create({
+    container: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        width,
+        height,
+        backgroundColor: '#000',
+    },
+    closeIcon: {
+        position: 'absolute',
+        left: 20,
+        top: 0,
+        zIndex: 1010,
+    },
+    closeImg: {
+        width: 26,
+        height: 26,
+        tintColor: '#FFF',
+    },
+    albumIcon: {
+        position: 'absolute',
+        right: 20,
+        bottom: 40,
+        zIndex: 1010,
+        backgroundColor: 'rgba(0,0,0,0.5)',
+        padding: 12,
+        borderRadius: 30,
+    },
+    albumImg: {
+        width: 24,
+        height: 24,
+        tintColor: '#FFF',
+    },
+});

package/dist/PreviewImageHostBridge.d.ts

@@ -0,0 +1,8 @@
+export type PreviewImagePayload = {
+    urls: string[];
+    current?: string;
+    showMenu?: boolean;
+    saveMediaText?: string;
+    cancelText?: string;
+};
+export declare const previewImageHostApi: import("@nebula-rn/sdk").NebulaHostFeature;

package/dist/PreviewImageHostBridge.js

@@ -0,0 +1,21 @@
+import { createHostModalApiFeature } from '@nebula-rn/sdk';
+import NebulaHostPreviewImageModal from './NebulaHostPreviewImageModal';
+import { previewImageChannel } from './previewImageRuntime';
+export const previewImageHostApi = createHostModalApiFeature({
+    apiName: 'previewImage',
+    description: {
+        summary: 'Open a host-managed fullscreen image preview modal for one or more image URLs.',
+        description: 'Supports selecting the initial image and optionally showing save actions in the preview UI.',
+        tags: ['media', 'image', 'modal'],
+    },
+    component: NebulaHostPreviewImageModal,
+    channel: previewImageChannel,
+    createRequest: payload => ({
+        urls: payload.urls,
+        current: payload.current,
+        showMenu: payload.showMenu,
+        saveMediaText: payload.saveMediaText,
+        cancelText: payload.cancelText,
+    }),
+    onUnmountErrorMessage: 'previewImage:fail host preview was unmounted before completion',
+});

package/dist/ScanCodeHostBridge.d.ts

@@ -0,0 +1 @@
+export declare const scanCodeHostApi: import("@nebula-rn/sdk").NebulaHostFeature;

package/dist/ScanCodeHostBridge.js

@@ -0,0 +1,38 @@
+import { Camera } from 'react-native-vision-camera';
+import { createHostApiFailure, createHostModalApiFeature, } from '@nebula-rn/sdk';
+import NebulaHostScanModal from './NebulaHostScanModal';
+import { scanCodeChannel } from './scanCodeRuntime';
+import { Platform } from 'react-native';
+function normalizeScanTypes(scanTypes) {
+    const defaultTypes = ['qr', 'ean-13', 'code-128'];
+    if (!scanTypes || scanTypes.length === 0) {
+        return defaultTypes;
+    }
+    const normalized = scanTypes.filter(Boolean);
+    return normalized.length > 0 ? normalized : defaultTypes;
+}
+export const scanCodeHostApi = createHostModalApiFeature({
+    apiName: 'scanCode',
+    description: {
+        summary: 'Open a host-managed scanner modal and return the first detected barcode or QR code.',
+        description: 'Supports camera-based scanning and returns structured scan metadata when successful.',
+        tags: ['camera', 'scanner', 'modal'],
+    },
+    component: NebulaHostScanModal,
+    channel: scanCodeChannel,
+    createRequest: payload => ({
+        onlyFromCamera: payload.onlyFromCamera,
+        scanTypes: normalizeScanTypes(payload.scanType),
+    }),
+    onBeforeOpen: async () => {
+        if (Platform.OS === 'android') {
+            return null;
+        }
+        const permission = await Camera.requestCameraPermission();
+        if (permission !== 'granted') {
+            return createHostApiFailure('PERMISSION_DENIED', 'scanCode:fail permission denied');
+        }
+        return null;
+    },
+    onUnmountErrorMessage: 'scanCode:fail host scanner was unmounted before completion',
+});

package/dist/coreHostApis.d.ts

@@ -0,0 +1,8 @@
+type SaveMediaPayload = {
+    url: string;
+    type: 'photo' | 'video';
+    album?: string;
+};
+export declare const saveMediaHost: (payload: SaveMediaPayload) => Promise<import("@react-native-camera-roll/camera-roll").PhotoIdentifier>;
+export declare const coreHostApis: import("@nebula-rn/sdk").NebulaHostFeature[];
+export {};