@symbiote-native/camera 0.0.0-stage → 0.0.0

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);

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

@@ -0,0 +1,33 @@
+import type { ICameraViewHandle } from '../core';
+/** Solid twin of `expo-camera`'s `CameraView`, `ref` gets the handle of the view */
+export declare const CameraView: (props: import("@symbiote-native/components").IAccessibilityProps & import("@symbiote-native/components").IAriaProps & import("@symbiote-native/components").IResponderProps & {
+    facing?: import(".").ICameraType;
+    flash?: import(".").ICameraFlashMode;
+    zoom?: number;
+    mode?: import(".").ICameraMode;
+    mute?: boolean;
+    mirror?: boolean;
+    autofocus?: import(".").ICameraFocusMode;
+    active?: boolean;
+    videoQuality?: import(".").ICameraVideoQuality;
+    videoBitrate?: number;
+    animateShutter?: boolean;
+    pictureSize?: string;
+    selectedLens?: string;
+    enableTorch?: boolean;
+    videoStabilizationMode?: import(".").ICameraVideoStabilization;
+    barcodeScannerSettings?: import(".").ICameraBarcodeSettings;
+    responsiveOrientationWhenOrientationLocked?: boolean;
+    ratio?: import(".").ICameraRatio;
+    onCameraReady?: () => void;
+    onMountError?: (event: import(".").ICameraMountError) => void;
+    onBarcodeScanned?: (result: import(".").ICameraBarcodeScanningResult) => void;
+    onResponsiveOrientationChanged?: (event: import(".").ICameraResponsiveOrientation) => void;
+    onAvailableLensesChanged?: (event: import(".").ICameraAvailableLenses) => void;
+    style?: import("@symbiote-native/engine").IStyleProp<import("@symbiote-native/engine").IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: import("@symbiote-native/engine").ISymbioteEvent) => void;
+} & {
+    ref?: ((handle: ICameraViewHandle) => void) | undefined;
+}) => import("@symbiote-native/engine").ISymbioteNode | null;

package/build/solid/camera-view.js

@@ -0,0 +1,4 @@
+import { defineNativeViewComponent } from '@symbiote-native/solid';
+import { createCameraView } from '../core/index.js';
+/** Solid twin of `expo-camera`'s `CameraView`, `ref` gets the handle of the view */
+export const CameraView = defineNativeViewComponent(createCameraView);

package/build/solid/index.d.ts

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

package/build/solid/index.js

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

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

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

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

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

package/build/svelte/camera-view.svelte

@@ -0,0 +1,32 @@
+<script lang="ts">
+  // The native view name is mixed-case, which a literal tag would parse as a component reference,
+  // so the tag is dynamic
+  import { hostProps } from '@symbiote-native/svelte/native-view-bridge';
+  import { useNativeViewController } from '@symbiote-native/svelte/runes/use-native-view-controller';
+  import { createCameraView } from '../core';
+  import type { ICameraViewProps } from '../core';
+
+  const props: ICameraViewProps = $props();
+  const view = useNativeViewController(createCameraView, () => ({ ...props }));
+
+  // The functions of the view are instance members, `bind:this` reaches them
+  export const takePictureAsync = view.handle.takePictureAsync;
+  export const recordAsync = view.handle.recordAsync;
+  export const toggleRecordingAsync = view.handle.toggleRecordingAsync;
+  export const stopRecording = view.handle.stopRecording;
+  export const pausePreview = view.handle.pausePreview;
+  export const resumePreview = view.handle.resumePreview;
+  export const getAvailablePictureSizesAsync =
+    view.handle.getAvailablePictureSizesAsync;
+  export const getAvailableLensesAsync = view.handle.getAvailableLensesAsync;
+  export const getSupportedFeatures = view.handle.getSupportedFeatures;
+  export const getHostNode = view.handle.getHostNode;
+</script>
+
+{#if view.descriptor}
+  <svelte:element
+    this={view.descriptor.type}
+    {@attach view.attachHost}
+    {@attach hostProps(view.descriptor.props)}
+  />
+{/if}

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

@@ -0,0 +1,22 @@
+import type { ICameraViewProps } from '../core';
+declare const CameraView: import("svelte").Component<ICameraViewProps, {
+    takePictureAsync: {
+        (options: import(".").ICameraPictureOptions & {
+            pictureRef: true;
+        }): Promise<import(".").ICameraPictureRef | undefined>;
+        (options?: import(".").ICameraPictureOptions): Promise<import(".").ICameraCapturedPicture | undefined>;
+    };
+    recordAsync: (options?: import(".").ICameraRecordingOptions) => Promise<{
+        uri: string;
+    } | undefined>;
+    toggleRecordingAsync: () => Promise<void>;
+    stopRecording: () => void;
+    pausePreview: () => Promise<void>;
+    resumePreview: () => Promise<void>;
+    getAvailablePictureSizesAsync: () => Promise<string[]>;
+    getAvailableLensesAsync: () => Promise<string[]>;
+    getSupportedFeatures: () => import(".").ICameraSupportedFeatures;
+    getHostNode: () => import("@symbiote-native/engine").ISymbioteNode | null;
+}, "">;
+type CameraView = ReturnType<typeof CameraView>;
+export default CameraView;

package/build/svelte/index.d.ts

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

package/build/svelte/index.js

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

package/build/svelte/use-camera-permissions.svelte.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) => {
+    readonly status: PermissionResponse | null;
+    requestPermission: () => Promise<PermissionResponse>;
+    getPermission: () => Promise<PermissionResponse>;
+};
+export declare const useCameraPermissions: IUseCameraPermissionsHook;
+export declare const useMicrophonePermissions: IUseCameraPermissionsHook;

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

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

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

@@ -0,0 +1,2 @@
+/** Vue twin of `expo-camera`'s `CameraView` */
+export declare const CameraView: import("vue").DefineComponent<{}, () => import("vue").VNode | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/vue/camera-view.js

@@ -0,0 +1,4 @@
+import { defineNativeViewComponent } from '@symbiote-native/vue';
+import { createCameraView } from '../core/index.js';
+/** Vue twin of `expo-camera`'s `CameraView` */
+export const CameraView = defineNativeViewComponent('CameraView', createCameraView);

package/build/vue/index.d.ts

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

package/build/vue/index.js

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

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

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

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

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