@symbiote-native/camera 0.0.0-stage → 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# @symbiote-native/camera
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[`expo-camera`](https://docs.expo.dev/versions/latest/sdk/camera/) for **every**
+[SymbioteNative](../../README.md) adapter: React, Vue, Svelte, Solid and Angular. The camera
+preview, pictures, video recording and barcode scanning.
+
+## Install
+
+```bash
+npx @symbiote-native/cli new my-app --camera   # new app
+npx @symbiote-native/cli add --camera          # existing app
+```
+
+Manual: `npm install @symbiote-native/camera`, then wire `expo-modules-autolinking` once per app.
+Never install `expo-camera` or the `expo` meta-package yourself.
+
+## Usage
+
+```tsx
+import { CameraView, useCameraPermissions, type ICameraViewHandle } from '@symbiote-native/camera/react';
+
+const [permission, requestPermission] = useCameraPermissions();
+const ref = useRef<ICameraViewHandle>(null);
+
+<CameraView ref={ref} style={{ flex: 1 }} facing="back" onBarcodeScanned={scan => console.log(scan.data)} />;
+
+const picture = await ref.current?.takePictureAsync({ quality: 0.8 });
+```
+
+The view takes the props of upstream's `CameraView` plus the View surface. The handle has
+`takePictureAsync`, `recordAsync`, `toggleRecordingAsync`, `stopRecording`, `pausePreview`,
+`resumePreview`, `getAvailablePictureSizesAsync`, `getAvailableLensesAsync` and
+`getSupportedFeatures`. A `ref` carries it in React and Solid (`ref={fn}`), the exposed members of
+a template ref in Vue, `bind:this` in Svelte and `@ViewChild` in Angular.
+
+The static members of upstream's `CameraView` are functions of the package: `isCameraAvailableAsync`
+(was `CameraView.isAvailableAsync`), `getAvailableVideoCodecsAsync`, `launchScanner`,
+`dismissScanner`, `onModernBarcodeScanned` and `isModernBarcodeScannerAvailable()`. `Camera`,
+`scanFromURLAsync` and `PictureRef` keep their names. The permission hooks are
+`useCameraPermissions` and `useMicrophonePermissions`, in Angular `CameraPermissionsService` and
+`MicrophonePermissionsService`.
+
+## App setup
+
+The package declares what `expo-camera`'s config plugin adds, and the `expo-modules-link`
+postinstall writes it into the app:
+
+| File                 | Entry                                                          |
+| -------------------- | -------------------------------------------------------------- |
+| `Info.plist`         | `NSCameraUsageDescription`, `NSMicrophoneUsageDescription`     |
+| `AndroidManifest.xml`| `CAMERA`, `RECORD_AUDIO`                                       |
+
+## Not ported
+
+The web build (`.web` files, the browser barcode detector) and the plugin's
+`barcodeScannerEnabled: false` switch, which only trims the native binary size. The only upstream
+test covers the web manager, the suites here are written against the native behavior.

package/build/angular/camera-view/index.d.ts

@@ -0,0 +1,43 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { ICameraViewHandle, ICameraViewProps } from '../../core';
+/** Angular twin of `expo-camera`'s `CameraView` */
+export declare class CameraView extends NativeViewBase {
+    facing?: ICameraViewProps['facing'];
+    flash?: ICameraViewProps['flash'];
+    zoom?: ICameraViewProps['zoom'];
+    mode?: ICameraViewProps['mode'];
+    mute?: ICameraViewProps['mute'];
+    mirror?: ICameraViewProps['mirror'];
+    autofocus?: ICameraViewProps['autofocus'];
+    active?: ICameraViewProps['active'];
+    videoQuality?: ICameraViewProps['videoQuality'];
+    videoBitrate?: ICameraViewProps['videoBitrate'];
+    animateShutter?: ICameraViewProps['animateShutter'];
+    pictureSize?: ICameraViewProps['pictureSize'];
+    selectedLens?: ICameraViewProps['selectedLens'];
+    enableTorch?: ICameraViewProps['enableTorch'];
+    videoStabilizationMode?: ICameraViewProps['videoStabilizationMode'];
+    barcodeScannerSettings?: ICameraViewProps['barcodeScannerSettings'];
+    responsiveOrientationWhenOrientationLocked?: ICameraViewProps['responsiveOrientationWhenOrientationLocked'];
+    ratio?: ICameraViewProps['ratio'];
+    onCameraReady?: ICameraViewProps['onCameraReady'];
+    onMountError?: ICameraViewProps['onMountError'];
+    onBarcodeScanned?: ICameraViewProps['onBarcodeScanned'];
+    onResponsiveOrientationChanged?: ICameraViewProps['onResponsiveOrientationChanged'];
+    onAvailableLensesChanged?: ICameraViewProps['onAvailableLensesChanged'];
+    private readonly view;
+    readonly takePictureAsync: ICameraViewHandle['takePictureAsync'];
+    readonly recordAsync: ICameraViewHandle['recordAsync'];
+    readonly toggleRecordingAsync: ICameraViewHandle['toggleRecordingAsync'];
+    readonly stopRecording: ICameraViewHandle['stopRecording'];
+    readonly pausePreview: ICameraViewHandle['pausePreview'];
+    readonly resumePreview: ICameraViewHandle['resumePreview'];
+    readonly getAvailablePictureSizesAsync: ICameraViewHandle['getAvailablePictureSizesAsync'];
+    readonly getAvailableLensesAsync: ICameraViewHandle['getAvailableLensesAsync'];
+    readonly getSupportedFeatures: ICameraViewHandle['getSupportedFeatures'];
+    readonly getHostNode: ICameraViewHandle['getHostNode'];
+    constructor();
+    protected readonly propNames: readonly ["facing", "flash", "zoom", "mode", "mute", "mirror", "autofocus", "active", "videoQuality", "videoBitrate", "animateShutter", "pictureSize", "selectedLens", "enableTorch", "videoStabilizationMode", "barcodeScannerSettings", "responsiveOrientationWhenOrientationLocked", "ratio", "onCameraReady", "onMountError", "onBarcodeScanned", "onResponsiveOrientationChanged", "onAvailableLensesChanged"];
+    protected renderView(props: object): IDescriptor | null;
+}

package/build/angular/camera-view/index.js

@@ -0,0 +1,101 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { DescriptorOutlet, NativeViewBase } from '@symbiote-native/angular';
+import { createCameraView } from '../../core/index.js';
+// One list is the inputs of the component and the props it hands to the native view
+const CAMERA_VIEW_INPUTS = [
+    'facing',
+    'flash',
+    'zoom',
+    'mode',
+    'mute',
+    'mirror',
+    'autofocus',
+    'active',
+    'videoQuality',
+    'videoBitrate',
+    'animateShutter',
+    'pictureSize',
+    'selectedLens',
+    'enableTorch',
+    'videoStabilizationMode',
+    'barcodeScannerSettings',
+    'responsiveOrientationWhenOrientationLocked',
+    'ratio',
+    'onCameraReady',
+    'onMountError',
+    'onBarcodeScanned',
+    'onResponsiveOrientationChanged',
+    'onAvailableLensesChanged',
+];
+/** Angular twin of `expo-camera`'s `CameraView` */
+let CameraView = (() => {
+    let _classDecorators = [Component({
+            selector: 'CameraView',
+            standalone: true,
+            imports: [DescriptorOutlet],
+            inputs: [...CAMERA_VIEW_INPUTS],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-outlet [node]="node" />
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    var CameraView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            CameraView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        view = createCameraView(() => this.hostNode());
+        constructor() {
+            super();
+            Object.assign(this, this.view.handle);
+        }
+        propNames = CAMERA_VIEW_INPUTS;
+        renderView(props) {
+            return this.view.render(props);
+        }
+    };
+    return CameraView = _classThis;
+})();
+export { CameraView };

package/build/angular/index.d.ts

@@ -0,0 +1,3 @@
+export { CameraView } from './camera-view';
+export { CameraPermissionsService, MicrophonePermissionsService, } from './services/camera-permissions.service';
+export * from '../core';

package/build/angular/index.js

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

package/build/angular/services/camera-permissions.service.d.ts

@@ -0,0 +1,8 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from 'expo-modules-core';
+export declare class CameraPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}
+export declare class MicrophonePermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}

package/build/angular/services/camera-permissions.service.js

@@ -0,0 +1,82 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { cameraPermissionMethods, microphonePermissionMethods, } from '../../core/camera-api.js';
+// Angular twin of `../../react`'s camera permission hooks
+let CameraPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var CameraPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            CameraPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(cameraPermissionMethods.getMethod, cameraPermissionMethods.requestMethod);
+        }
+    };
+    return CameraPermissionsService = _classThis;
+})();
+export { CameraPermissionsService };
+let MicrophonePermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var MicrophonePermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            MicrophonePermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(microphonePermissionMethods.getMethod, microphonePermissionMethods.requestMethod);
+        }
+    };
+    return MicrophonePermissionsService = _classThis;
+})();
+export { MicrophonePermissionsService };

package/build/core/android-barcode.d.ts

@@ -0,0 +1,50 @@
+type IAndroidBarcodeKind<TType extends string> = {
+    type: TType;
+};
+export type IAndroidBarcode = (IAndroidBarcodeKind<'contactInfo'> & {
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    title?: string;
+    organization?: string;
+    email?: string;
+    phone?: string;
+    url?: string;
+    address?: string;
+}) | (IAndroidBarcodeKind<'geoPoint'> & {
+    lat: string;
+    lng: string;
+}) | (IAndroidBarcodeKind<'sms'> & {
+    phoneNumber?: string;
+    message?: string;
+}) | (IAndroidBarcodeKind<'url'> & {
+    url?: string;
+}) | (IAndroidBarcodeKind<'calendarEvent'> & {
+    summary?: string;
+    description?: string;
+    location?: string;
+    start?: string;
+    end?: string;
+}) | (IAndroidBarcodeKind<'driverLicense'> & {
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    licenseNumber?: string;
+    expiryDate?: string;
+    issueDate?: string;
+    addressStreet?: string;
+    addressCity?: string;
+    addressState?: string;
+}) | (IAndroidBarcodeKind<'email'> & {
+    address?: string;
+    subject?: string;
+    body?: string;
+}) | (IAndroidBarcodeKind<'phone'> & {
+    number?: string;
+    phoneNumberType?: string;
+}) | (IAndroidBarcodeKind<'wifi'> & {
+    ssid?: string;
+    password?: string;
+    encryptionType?: string;
+});
+export {};

package/build/core/android-barcode.js

@@ -0,0 +1,2 @@
+// What Google's code scanner adds to a result, Android only
+export {};

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

@@ -0,0 +1,35 @@
+import type { EventSubscription, PermissionResponse } from 'expo-modules-core';
+import type { ICameraBarcodeScanningResult, ICameraBarcodeType, ICameraScanningOptions, ICameraScanningResult, ICameraVideoCodec } from './types';
+/** Whether the device has a camera, the permissions are a separate question */
+export declare function isCameraAvailableAsync(): Promise<boolean>;
+/** iOS only */
+export declare function getAvailableVideoCodecsAsync(): Promise<ICameraVideoCodec[]>;
+/** Whether the device has `DataScannerViewController` (iOS 16+) or Google's code scanner */
+export declare function isModernBarcodeScannerAvailable(): boolean;
+/** A device without the modern scanner does nothing here */
+export declare function launchScanner(options?: ICameraScanningOptions): Promise<void>;
+/** Dismisses the scanner on iOS, on Android it closes itself after a scan */
+export declare function dismissScanner(): Promise<void>;
+export declare function onModernBarcodeScanned(listener: (event: ICameraScanningResult) => void): EventSubscription;
+/** Only QR codes are scanned on iOS */
+export declare function scanFromURLAsync(url: string, barcodeTypes?: ICameraBarcodeType[]): Promise<ICameraBarcodeScanningResult[]>;
+declare function getCameraPermissionsAsync(): Promise<PermissionResponse>;
+declare function requestCameraPermissionsAsync(): Promise<PermissionResponse>;
+declare function getMicrophonePermissionsAsync(): Promise<PermissionResponse>;
+declare function requestMicrophonePermissionsAsync(): Promise<PermissionResponse>;
+export declare const Camera: {
+    getCameraPermissionsAsync: typeof getCameraPermissionsAsync;
+    requestCameraPermissionsAsync: typeof requestCameraPermissionsAsync;
+    getMicrophonePermissionsAsync: typeof getMicrophonePermissionsAsync;
+    requestMicrophonePermissionsAsync: typeof requestMicrophonePermissionsAsync;
+    scanFromURLAsync: typeof scanFromURLAsync;
+};
+export declare const cameraPermissionMethods: {
+    getMethod: typeof getCameraPermissionsAsync;
+    requestMethod: typeof requestCameraPermissionsAsync;
+};
+export declare const microphonePermissionMethods: {
+    getMethod: typeof getMicrophonePermissionsAsync;
+    requestMethod: typeof requestMicrophonePermissionsAsync;
+};
+export {};

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,40 @@
+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;