@symbiote-native/camera 0.0.0-stage → 0.1.0

package/build/core/camera-api.js

@@ -0,0 +1,68 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { CAMERA_PACKAGE_NAME, MODERN_SCANNER_EVENT } from './constants.js';
+import { expoCamera } from './native-module.js';
+/** Whether the device has a camera, the permissions are a separate question */
+export async function isCameraAvailableAsync() {
+    if (!expoCamera.isAvailableAsync) {
+        throw new UnavailabilityError(CAMERA_PACKAGE_NAME, 'isAvailableAsync');
+    }
+    return expoCamera.isAvailableAsync();
+}
+/** iOS only */
+export async function getAvailableVideoCodecsAsync() {
+    if (!expoCamera.getAvailableVideoCodecsAsync) {
+        throw new UnavailabilityError('Camera', 'getAvailableVideoCodecsAsync');
+    }
+    return expoCamera.getAvailableVideoCodecsAsync();
+}
+/** Whether the device has `DataScannerViewController` (iOS 16+) or Google's code scanner */
+export function isModernBarcodeScannerAvailable() {
+    return expoCamera.isModernBarcodeScannerAvailable;
+}
+/** A device without the modern scanner does nothing here */
+export async function launchScanner(options = { barcodeTypes: [] }) {
+    if (expoCamera.isModernBarcodeScannerAvailable) {
+        await expoCamera.launchScanner(options);
+    }
+}
+/** Dismisses the scanner on iOS, on Android it closes itself after a scan */
+export async function dismissScanner() {
+    if (expoCamera.isModernBarcodeScannerAvailable) {
+        await expoCamera.dismissScanner();
+    }
+}
+export function onModernBarcodeScanned(listener) {
+    return expoCamera.addListener(MODERN_SCANNER_EVENT, listener);
+}
+/** Only QR codes are scanned on iOS */
+export async function scanFromURLAsync(url, barcodeTypes = ['qr']) {
+    return expoCamera.scanFromURLAsync(url, barcodeTypes);
+}
+async function getCameraPermissionsAsync() {
+    return expoCamera.getCameraPermissionsAsync();
+}
+async function requestCameraPermissionsAsync() {
+    return expoCamera.requestCameraPermissionsAsync();
+}
+async function getMicrophonePermissionsAsync() {
+    return expoCamera.getMicrophonePermissionsAsync();
+}
+async function requestMicrophonePermissionsAsync() {
+    return expoCamera.requestMicrophonePermissionsAsync();
+}
+export const Camera = {
+    getCameraPermissionsAsync,
+    requestCameraPermissionsAsync,
+    getMicrophonePermissionsAsync,
+    requestMicrophonePermissionsAsync,
+    scanFromURLAsync,
+};
+// What every adapter's `createPermissionHook` binds, `useCameraPermissions` and its twin
+export const cameraPermissionMethods = {
+    getMethod: getCameraPermissionsAsync,
+    requestMethod: requestCameraPermissionsAsync,
+};
+export const microphonePermissionMethods = {
+    getMethod: getMicrophonePermissionsAsync,
+    requestMethod: requestMicrophonePermissionsAsync,
+};

package/build/core/camera-view-events.d.ts

@@ -0,0 +1,3 @@
+export type ICameraViewEvents = (props: object) => Record<string, unknown>;
+/** One per view, the throttle of the barcode events belongs to the view */
+export declare function createCameraViewEvents(): ICameraViewEvents;

package/build/core/camera-view-events.js

@@ -0,0 +1,60 @@
+import { BARCODE_EVENT_THROTTLE_MS } from './constants.js';
+import { handlePictureSaved } from './picture-options.js';
+function hasField(value, key, kind) {
+    return typeof Reflect.get(Object(value), key) === kind;
+}
+const isMountError = (value) => hasField(value, 'message', 'string');
+const isOrientation = (value) => hasField(value, 'orientation', 'string');
+const isLenses = (value) => Array.isArray(Reflect.get(Object(value), 'lenses'));
+const isScanningResult = (value) => hasField(value, 'type', 'string') && hasField(value, 'data', 'string');
+function isPictureSaved(value) {
+    return hasField(value, 'id', 'number') && hasField(value, 'data', 'object');
+}
+// Hands the callback the payload inside the native event, and only when it has the expected shape
+function forward(props, name, isPayload) {
+    return (event) => {
+        const callback = Reflect.get(props, name);
+        if (typeof callback === 'function' && isPayload(event.nativeEvent)) {
+            callback(event.nativeEvent);
+        }
+    };
+}
+/** One per view, the throttle of the barcode events belongs to the view */
+export function createCameraViewEvents() {
+    const lastScans = new Map();
+    // Equal events of one type inside the window are the same scan seen again
+    const throttledScan = (callback) => (event) => {
+        const result = event.nativeEvent;
+        if (!isScanningResult(result))
+            return;
+        const json = JSON.stringify(result);
+        const now = Date.now();
+        const last = lastScans.get(result.type);
+        if (last?.json === json && now - last.at < BARCODE_EVENT_THROTTLE_MS) {
+            return;
+        }
+        callback(result);
+        lastScans.set(result.type, { json, at: now });
+    };
+    return props => {
+        const onBarcodeScanned = Reflect.get(props, 'onBarcodeScanned');
+        const onCameraReady = Reflect.get(props, 'onCameraReady');
+        return {
+            onCameraReady: () => {
+                if (typeof onCameraReady === 'function')
+                    onCameraReady();
+            },
+            onMountError: forward(props, 'onMountError', isMountError),
+            onBarcodeScanned: typeof onBarcodeScanned === 'function'
+                ? throttledScan(result => onBarcodeScanned(result))
+                : undefined,
+            onAvailableLensesChanged: forward(props, 'onAvailableLensesChanged', isLenses),
+            onResponsiveOrientationChanged: forward(props, 'onResponsiveOrientationChanged', isOrientation),
+            onPictureSaved: (event) => {
+                if (isPictureSaved(event.nativeEvent)) {
+                    handlePictureSaved({ nativeEvent: event.nativeEvent });
+                }
+            },
+        };
+    };
+}

package/build/core/camera-view-handle.d.ts

@@ -0,0 +1,26 @@
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import type { ICameraPictureRef } from './native-module';
+import type { ICameraCapturedPicture, ICameraPictureOptions, ICameraRecordingOptions, ICameraSupportedFeatures } from './types';
+export type ICameraViewHandle = {
+    /** Waits for `onCameraReady` first. With `pictureRef` it resolves to a native image reference */
+    takePictureAsync(options: ICameraPictureOptions & {
+        pictureRef: true;
+    }): Promise<ICameraPictureRef | undefined>;
+    takePictureAsync(options?: ICameraPictureOptions): Promise<ICameraCapturedPicture | undefined>;
+    /** Resolves when `stopRecording` runs, a limit is reached or the preview stops */
+    recordAsync(options?: ICameraRecordingOptions): Promise<{
+        uri: string;
+    } | undefined>;
+    /** Pauses or resumes the recording, iOS 18 and later on iOS */
+    toggleRecordingAsync(): Promise<void>;
+    stopRecording(): void;
+    pausePreview(): Promise<void>;
+    resumePreview(): Promise<void>;
+    getAvailablePictureSizesAsync(): Promise<string[]>;
+    /** Lenses exist on iOS only */
+    getAvailableLensesAsync(): Promise<string[]>;
+    getSupportedFeatures(): ICameraSupportedFeatures;
+    /** The host node of the mounted view, `createCameraTextureAsync` of a GL view takes it */
+    getHostNode(): ISymbioteNode | null;
+};
+export declare function createCameraViewHandle(getNode: () => ISymbioteNode | null | undefined): ICameraViewHandle;

package/build/core/camera-view-handle.js

@@ -0,0 +1,46 @@
+import { Platform, requireNativeModule } from 'expo-modules-core';
+import { defineExpoViewMethods, getNativeTag } from '@symbiote-native/engine';
+import { CAMERA_MODULE_NAME } from './constants.js';
+import { expoCamera } from './native-module.js';
+import { ensurePictureOptions, ensureRecordingOptions, } from './picture-options.js';
+const callViewFunction = defineExpoViewMethods(requireNativeModule, CAMERA_MODULE_NAME);
+export function createCameraViewHandle(getNode) {
+    // Like upstream's `ref.current?.`, a view that has not committed yet answers nothing
+    function call(method, args = []) {
+        const node = getNode();
+        if (!node || getNativeTag(node) === undefined)
+            return undefined;
+        return callViewFunction(node, method, args);
+    }
+    async function takePictureAsync(options) {
+        const pictureOptions = ensurePictureOptions(options);
+        // The picture ref is an iOS feature, Android answers a plain picture
+        if (Platform.select({ ios: Boolean(options?.pictureRef), default: false })) {
+            return call('takePictureRef', [
+                pictureOptions,
+            ]);
+        }
+        return call('takePicture', [
+            pictureOptions,
+        ]);
+    }
+    return {
+        takePictureAsync,
+        recordAsync: async (options) => call('record', [
+            ensureRecordingOptions(options),
+        ]),
+        toggleRecordingAsync: async () => call('toggleRecording'),
+        stopRecording: () => {
+            call('stopRecording');
+        },
+        pausePreview: async () => call('pausePreview'),
+        resumePreview: async () => call('resumePreview'),
+        getAvailablePictureSizesAsync: async () => (await call('getAvailablePictureSizes')) ?? [],
+        getAvailableLensesAsync: async () => (await call('getAvailableLenses')) ?? [],
+        getSupportedFeatures: () => ({
+            isModernBarcodeScannerAvailable: expoCamera.isModernBarcodeScannerAvailable,
+            toggleRecordingAsyncAvailable: expoCamera.toggleRecordingAsyncAvailable,
+        }),
+        getHostNode: () => getNode() ?? null,
+    };
+}

package/build/core/camera-view.d.ts

@@ -0,0 +1,12 @@
+import type { IDescriptor } from '@symbiote-native/components';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import type { ICameraViewHandle } from './camera-view-handle';
+export declare const cameraViewName: () => string;
+export declare const ensureCameraViewRegistered: () => boolean;
+export type ICameraView = {
+    handle: ICameraViewHandle;
+    /** `null` means the view cannot register and the caller renders nothing */
+    render(props: object): IDescriptor | null;
+};
+/** One per mounted view, `getNode` answers the host node once it exists */
+export declare function createCameraView(getNode: () => ISymbioteNode | null | undefined): ICameraView;

package/build/core/camera-view.js

@@ -0,0 +1,38 @@
+// Ядро `CameraView`: нативный view камеры, чьи функции вызываются через `ViewPrototypes`
+import { requireNativeViewManager } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeView, isDevBuild } from '@symbiote-native/engine';
+import { createCameraViewEvents } from './camera-view-events.js';
+import { createCameraViewHandle } from './camera-view-handle.js';
+import { CAMERA_MODULE_NAME } from './constants.js';
+import { ensureNativeProps } from './props.js';
+// Регистрация идёт при рендере: побочный эффект барреля теряется в release
+const cameraView = defineExpoNativeView(requireNativeViewManager, CAMERA_MODULE_NAME);
+export const cameraViewName = cameraView.name;
+export const ensureCameraViewRegistered = cameraView.ensureRegistered;
+// What upstream's `defaultProps` gave the class component
+const DEFAULT_VIEW_PROPS = {
+    zoom: 0,
+    facing: 'back',
+    enableTorch: false,
+    mode: 'picture',
+    flash: 'off',
+};
+/** One per mounted view, `getNode` answers the host node once it exists */
+export function createCameraView(getNode) {
+    const toEvents = createCameraViewEvents();
+    return {
+        handle: createCameraViewHandle(getNode),
+        render: props => {
+            if (!ensureCameraViewRegistered()) {
+                if (isDevBuild())
+                    console.warn("'CameraView' is not available.");
+                return null;
+            }
+            return el(cameraViewName(), {
+                ...ensureNativeProps({ ...DEFAULT_VIEW_PROPS, ...props }),
+                ...toEvents(props),
+            });
+        },
+    };
+}

package/build/core/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CAMERA_MODULE_NAME = "ExpoCamera";
+/** The label upstream puts into its `UnavailabilityError` */
+export declare const CAMERA_PACKAGE_NAME = "expo-camera";
+/** Equal barcode events of one type inside this window are dropped */
+export declare const BARCODE_EVENT_THROTTLE_MS = 500;
+export declare const MODERN_SCANNER_EVENT = "onModernBarcodeScanned";

package/build/core/constants.js

@@ -0,0 +1,7 @@
+// Apart from `native-module`, which resolves the module on import: the view needs the name too
+export const CAMERA_MODULE_NAME = 'ExpoCamera';
+/** The label upstream puts into its `UnavailabilityError` */
+export const CAMERA_PACKAGE_NAME = 'expo-camera';
+/** Equal barcode events of one type inside this window are dropped */
+export const BARCODE_EVENT_THROTTLE_MS = 500;
+export const MODERN_SCANNER_EVENT = 'onModernBarcodeScanned';

package/build/core/index.d.ts

@@ -0,0 +1,9 @@
+export { Camera, cameraPermissionMethods, dismissScanner, getAvailableVideoCodecsAsync, isCameraAvailableAsync, isModernBarcodeScannerAvailable, launchScanner, microphonePermissionMethods, onModernBarcodeScanned, scanFromURLAsync, } from './camera-api';
+export { cameraViewName, createCameraView, ensureCameraViewRegistered, type ICameraView, } from './camera-view';
+export type { ICameraViewHandle } from './camera-view-handle';
+export { CAMERA_MODULE_NAME } from './constants';
+export type { ICameraPictureRef } from './native-module';
+export { PictureRef } from './picture-ref';
+export type { IAndroidBarcode } from './android-barcode';
+export type { ICameraAvailableLenses, ICameraBarcodeBounds, ICameraBarcodePoint, ICameraBarcodeScanningResult, ICameraBarcodeSettings, ICameraBarcodeType, ICameraCapturedPicture, ICameraFlashMode, ICameraFocusMode, ICameraMode, ICameraMountError, ICameraOrientation, ICameraPhotoResult, ICameraPictureOptions, ICameraRatio, ICameraRecordingOptions, ICameraResponsiveOrientation, ICameraSavePictureOptions, ICameraScanningOptions, ICameraScanningResult, ICameraSupportedFeatures, ICameraType, ICameraVideoCodec, ICameraVideoQuality, ICameraVideoStabilization, ICameraViewProps, } from './types';
+export { PermissionStatus, type EventSubscription, type PermissionExpiration, type PermissionResponse, } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,5 @@
+export { Camera, cameraPermissionMethods, dismissScanner, getAvailableVideoCodecsAsync, isCameraAvailableAsync, isModernBarcodeScannerAvailable, launchScanner, microphonePermissionMethods, onModernBarcodeScanned, scanFromURLAsync, } from './camera-api.js';
+export { cameraViewName, createCameraView, ensureCameraViewRegistered, } from './camera-view.js';
+export { CAMERA_MODULE_NAME } from './constants.js';
+export { PictureRef } from './picture-ref.js';
+export { PermissionStatus, } from 'expo-modules-core';

package/build/core/native-module.d.ts

@@ -0,0 +1,28 @@
+import type { EventSubscription, PermissionResponse, SharedRef } from 'expo-modules-core';
+import type { ICameraBarcodeScanningResult, ICameraBarcodeType, ICameraPhotoResult, ICameraSavePictureOptions, ICameraScanningOptions, ICameraScanningResult, ICameraVideoCodec } from './types';
+/** A reference to a native instance of an image, other Expo packages accept it as is */
+export type ICameraPictureRef = SharedRef<'image'> & {
+    width: number;
+    height: number;
+    /** Saves the image into the cache directory */
+    savePictureAsync(options?: ICameraSavePictureOptions): Promise<ICameraPhotoResult>;
+};
+export type ICameraPictureRefClass = abstract new (...args: never[]) => ICameraPictureRef;
+export type ICameraNativeModule = {
+    Picture: ICameraPictureRefClass;
+    readonly isModernBarcodeScannerAvailable: boolean;
+    readonly toggleRecordingAsyncAvailable: boolean;
+    readonly Type: Record<string, string>;
+    readonly FlashMode: Record<string, string>;
+    isAvailableAsync?(): Promise<boolean>;
+    launchScanner(options?: ICameraScanningOptions): Promise<void>;
+    dismissScanner(): Promise<void>;
+    scanFromURLAsync(url: string, barcodeTypes?: ICameraBarcodeType[]): Promise<ICameraBarcodeScanningResult[]>;
+    getCameraPermissionsAsync(): Promise<PermissionResponse>;
+    requestCameraPermissionsAsync(): Promise<PermissionResponse>;
+    getMicrophonePermissionsAsync(): Promise<PermissionResponse>;
+    requestMicrophonePermissionsAsync(): Promise<PermissionResponse>;
+    getAvailableVideoCodecsAsync?(): Promise<ICameraVideoCodec[]>;
+    addListener(eventName: string, listener: (event: ICameraScanningResult) => void): EventSubscription;
+};
+export declare const expoCamera: ICameraNativeModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { CAMERA_MODULE_NAME } from './constants.js';
+export const expoCamera = requireNativeModule(CAMERA_MODULE_NAME);

package/build/core/picture-options.d.ts

@@ -0,0 +1,9 @@
+import type { ICameraCapturedPicture, ICameraPictureOptions, ICameraRecordingOptions } from './types';
+export declare function ensurePictureOptions(options?: ICameraPictureOptions): ICameraPictureOptions;
+export declare function ensureRecordingOptions(options?: ICameraRecordingOptions): ICameraRecordingOptions;
+export declare function handlePictureSaved({ nativeEvent, }: {
+    nativeEvent: {
+        data: ICameraCapturedPicture;
+        id: number;
+    };
+}): void;

package/build/core/picture-options.js

@@ -0,0 +1,29 @@
+const MIRROR_DEPRECATED = 'The `mirror` option is deprecated. Please use the `mirror` prop on the `CameraView` instead.';
+// The callbacks wait here for the native event that carries their picture
+const pictureSavedCallbacks = new Map();
+let nextPictureId = 1;
+export function ensurePictureOptions(options) {
+    if (!options || typeof options !== 'object')
+        return {};
+    if (options.mirror)
+        console.warn(MIRROR_DEPRECATED);
+    const { onPictureSaved, ...rest } = options;
+    const withQuality = { ...rest, quality: options.quality ?? 1 };
+    if (!onPictureSaved)
+        return withQuality;
+    const id = nextPictureId++;
+    pictureSavedCallbacks.set(id, onPictureSaved);
+    return { ...withQuality, id, fastMode: true };
+}
+export function ensureRecordingOptions(options = {}) {
+    if (options.mirror)
+        console.warn(MIRROR_DEPRECATED);
+    return options;
+}
+export function handlePictureSaved({ nativeEvent, }) {
+    const callback = pictureSavedCallbacks.get(nativeEvent.id);
+    if (!callback)
+        return;
+    pictureSavedCallbacks.delete(nativeEvent.id);
+    callback(nativeEvent.data);
+}

package/build/core/picture-ref.d.ts

@@ -0,0 +1,2 @@
+/** The native image class, `takePictureAsync({ pictureRef: true })` resolves to an instance */
+export declare const PictureRef: import("./native-module").ICameraPictureRefClass;

package/build/core/picture-ref.js

@@ -0,0 +1,3 @@
+import { expoCamera } from './native-module.js';
+/** The native image class, `takePictureAsync({ pictureRef: true })` resolves to an instance */
+export const PictureRef = expoCamera.Picture;

package/build/core/props.d.ts

@@ -0,0 +1,4 @@
+type INativeProps = Record<string, unknown>;
+/** The props the native view takes, built from the friendly ones of the view */
+export declare function ensureNativeProps(props: object): INativeProps;
+export {};

package/build/core/props.js

@@ -0,0 +1,26 @@
+import { expoCamera } from './native-module.js';
+// Values under these keys become native options, the tables come from the native module
+function conversionTableFor(key) {
+    if (key === 'type')
+        return expoCamera.Type;
+    if (key === 'flash')
+        return expoCamera.FlashMode;
+    return undefined;
+}
+function convertNativeProps(props) {
+    return Object.fromEntries(Object.entries(props).map(([key, value]) => {
+        const table = conversionTableFor(key);
+        return [key, typeof value === 'string' && table ? table[value] : value];
+    }));
+}
+/** The props the native view takes, built from the friendly ones of the view */
+export function ensureNativeProps(props) {
+    const { poster: _poster, ...native } = convertNativeProps(props);
+    return {
+        ...native,
+        barcodeScannerEnabled: Boolean(Reflect.get(props, 'onBarcodeScanned')),
+        flashMode: Reflect.get(props, 'flash') ?? 'off',
+        mute: Reflect.get(props, 'mute') ?? false,
+        autoFocus: Reflect.get(props, 'autofocus') ?? 'off',
+    };
+}

package/build/core/types.d.ts

@@ -0,0 +1,170 @@
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IAndroidBarcode } from './android-barcode';
+export type ICameraType = 'front' | 'back';
+/**
+ * `screen` uses the display as the flash of a front camera, on iOS it maps to `on`
+ * and Retina Flash fires
+ */
+export type ICameraFlashMode = 'off' | 'on' | 'auto' | 'screen';
+/** `on` focuses once and locks, `off` focuses whenever needed */
+export type ICameraFocusMode = 'on' | 'off';
+export type ICameraMode = 'picture' | 'video';
+export type ICameraRatio = '4:3' | '16:9' | '1:1';
+/** The codec of a video recording, iOS only */
+export type ICameraVideoCodec = 'avc1' | 'hvc1' | 'jpeg' | 'apcn' | 'ap4h';
+/** On Android all but `off` turn the stabilization on, the device picks the method */
+export type ICameraVideoStabilization = 'off' | 'standard' | 'cinematic' | 'auto';
+export type ICameraVideoQuality = '2160p' | '1080p' | '720p' | '480p' | '4:3';
+export type ICameraOrientation = 'portrait' | 'portraitUpsideDown' | 'landscapeLeft' | 'landscapeRight';
+export type ICameraBarcodeType = 'aztec' | 'ean13' | 'ean8' | 'qr' | 'pdf417' | 'upc_e' | 'datamatrix' | 'code39' | 'code93' | 'itf14' | 'codabar' | 'code128' | 'upc_a';
+export type ICameraCapturedPicture = {
+    width: number;
+    height: number;
+    format: 'jpg' | 'png';
+    uri: string;
+    /** Base64 of the JPEG data, present when the `base64` option was set */
+    base64?: string;
+    /** The EXIF tags and their values, present when the `exif` option was set */
+    exif?: Record<string, unknown>;
+};
+export type ICameraPictureOptions = {
+    /** From `0` (small) to `1` (best), `1` by default */
+    quality?: number;
+    base64?: boolean;
+    exif?: boolean;
+    /** Extra EXIF data, takes effect with `exif` */
+    additionalExif?: Record<string, unknown>;
+    /**
+     * Called when the picture is saved, the promise then resolves at once with no data
+     * and the picture goes to this callback
+     */
+    onPictureSaved?: (picture: ICameraCapturedPicture) => void;
+    /** Returns the image as it came from the sensor, `quality` is discarded */
+    skipProcessing?: boolean;
+    /** @deprecated Use the `mirror` prop of the view */
+    mirror?: boolean;
+    id?: number;
+    fastMode?: boolean;
+    maxDownsampling?: number;
+    /** `true` by default */
+    shutterSound?: boolean;
+    /** Resolves to a reference to the native image instead of a file */
+    pictureRef?: boolean;
+};
+export type ICameraRecordingOptions = {
+    /** In seconds */
+    maxDuration?: number;
+    /** In bytes */
+    maxFileSize?: number;
+    /** @deprecated Use the `mirror` prop of the view */
+    mirror?: boolean;
+    /** iOS only */
+    codec?: ICameraVideoCodec;
+};
+export type ICameraAvailableLenses = {
+    lenses: string[];
+};
+export type ICameraResponsiveOrientation = {
+    orientation: ICameraOrientation;
+};
+export type ICameraMountError = {
+    message: string;
+};
+export type ICameraBarcodePoint = {
+    x: number;
+    y: number;
+};
+export type ICameraBarcodeBounds = {
+    origin: ICameraBarcodePoint;
+    size: {
+        height: number;
+        width: number;
+    };
+};
+export type ICameraBarcodeScanningResult = {
+    type: string;
+    /** The parsed information encoded in the barcode */
+    data: string;
+    /** The raw information, Android only */
+    raw?: string;
+    /** The order of the points differs per platform, and is empty for some types */
+    cornerPoints: ICameraBarcodePoint[];
+    bounds: ICameraBarcodeBounds;
+    /** Extra information of the type of barcode, Android only */
+    extra?: IAndroidBarcode;
+};
+export type ICameraScanningResult = Omit<ICameraBarcodeScanningResult, 'bounds' | 'cornerPoints'>;
+export type ICameraBarcodeSettings = {
+    barcodeTypes: ICameraBarcodeType[];
+};
+/** The options of the system scanner, iOS 16+ and Google's code scanner on Android */
+export type ICameraScanningOptions = {
+    barcodeTypes: ICameraBarcodeType[];
+    /** iOS only, `true` by default */
+    isPinchToZoomEnabled?: boolean;
+    /** iOS only, `true` by default */
+    isGuidanceEnabled?: boolean;
+    /** iOS only, `false` by default */
+    isHighlightingEnabled?: boolean;
+};
+export type ICameraPhotoResult = {
+    uri: string;
+    width: number;
+    height: number;
+    base64?: string;
+};
+export type ICameraSavePictureOptions = {
+    quality?: number;
+    metadata?: Record<string, unknown>;
+    base64?: boolean;
+};
+export type ICameraViewProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    /** `back` by default */
+    facing?: ICameraType;
+    /** `off` by default */
+    flash?: ICameraFlashMode;
+    /** From `0` to `1`, a share of the maximum zoom of the device */
+    zoom?: number;
+    /** `picture` by default */
+    mode?: ICameraMode;
+    /** Records video with no sound */
+    mute?: boolean;
+    /** Mirrors the image of the front camera */
+    mirror?: boolean;
+    /** iOS only, `off` by default */
+    autofocus?: ICameraFocusMode;
+    /** Stops the session while `false`, iOS only, `true` by default */
+    active?: boolean;
+    videoQuality?: ICameraVideoQuality;
+    /** In bits per second, on iOS needs the codec in `recordAsync` */
+    videoBitrate?: number;
+    animateShutter?: boolean;
+    /** Makes `ratio` ignored, the sizes come from `getAvailablePictureSizesAsync` */
+    pictureSize?: string;
+    /** iOS only, `builtInWideAngleCamera` by default */
+    selectedLens?: string;
+    enableTorch?: boolean;
+    /** `auto` by default */
+    videoStabilizationMode?: ICameraVideoStabilization;
+    barcodeScannerSettings?: ICameraBarcodeSettings;
+    /** Takes landscape pictures of a portrait-locked app when the device turns, iOS only */
+    responsiveOrientationWhenOrientationLocked?: boolean;
+    /** Android only, switches the preview from fill to fit */
+    ratio?: ICameraRatio;
+    onCameraReady?: () => void;
+    onMountError?: (event: ICameraMountError) => void;
+    onBarcodeScanned?: (result: ICameraBarcodeScanningResult) => void;
+    /** iOS only */
+    onResponsiveOrientationChanged?: (event: ICameraResponsiveOrientation) => void;
+    /** iOS only */
+    onAvailableLensesChanged?: (event: ICameraAvailableLenses) => void;
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};
+export type ICameraSupportedFeatures = {
+    isModernBarcodeScannerAvailable: boolean;
+    toggleRecordingAsyncAvailable: boolean;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/camera-view.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement, Ref } from 'react';
+import type { ICameraViewHandle, ICameraViewProps } from '../core';
+export type ICameraViewReactProps = ICameraViewProps & {
+    ref?: Ref<ICameraViewHandle>;
+    className?: string;
+};
+/** React twin of `expo-camera`'s `CameraView` */
+export declare function CameraView({ ref, ...props }: ICameraViewReactProps): ReactElement | null;

package/build/react/camera-view.js

@@ -0,0 +1,6 @@
+import { useNativeViewController } from '@symbiote-native/react';
+import { createCameraView } from '../core/index.js';
+/** React twin of `expo-camera`'s `CameraView` */
+export function CameraView({ ref, ...props }) {
+    return useNativeViewController(ref, createCameraView, props);
+}

package/build/react/index.d.ts

@@ -0,0 +1,5 @@
+export { CameraView } from './camera-view';
+export type { ICameraViewReactProps } from './camera-view';
+export { useCameraPermissions, useMicrophonePermissions, } from './use-camera-permissions';
+export type { IUseCameraPermissionsHook } from './use-camera-permissions';
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/camera/react: камера, съёмка, запись видео и сканирование кодов на общем ядре
+export { CameraView } from './camera-view.js';
+export { useCameraPermissions, useMicrophonePermissions, } from './use-camera-permissions.js';
+export * from '../core/index.js';

package/build/react/use-camera-permissions.d.ts

@@ -0,0 +1,9 @@
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { PermissionResponse } from 'expo-modules-core';
+export type IUseCameraPermissionsHook = (options?: IPermissionHookBehavior) => [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare const useCameraPermissions: IUseCameraPermissionsHook;
+export declare const useMicrophonePermissions: IUseCameraPermissionsHook;

package/build/react/use-camera-permissions.js

@@ -0,0 +1,5 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { cameraPermissionMethods, microphonePermissionMethods, } from '../core/camera-api.js';
+// React twin of `expo-camera`'s permission hooks
+export const useCameraPermissions = createPermissionHook(cameraPermissionMethods);
+export const useMicrophonePermissions = createPermissionHook(microphonePermissionMethods);