@symbiote-native/camera 0.0.0-stage → 0.1.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,255 @@
-# 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.
+
+Built the same way as [`@symbiote-native/clipboard`](../clipboard)'s `ClipboardPasteButton`, an
+`expo-modules-core` native view reached through `requireNativeViewManager` (see the
+`symbiote-expo-native-module` project skill: why `expo-modules-core` is depended on directly and never
+the `expo` meta-package, why the upstream JS is hand-ported into `core/`, and how autolinking finds the
+native module). One render function in `core/` returns a descriptor and every adapter only turns it into
+its own element.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --camera
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --camera
+```
+
+Either way: installs `@symbiote-native/camera` and wires the native autolinking automatically,
+see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/camera
+```
+
+Depends on `expo-camera` and `expo-modules-core` directly (regular dependencies, pinned to exact
+versions, since this package's `core/` is hand-ported against one specific native API shape).
+Never install `expo-camera` yourself, and never add the `expo` package to this project: it bundles
+its own Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+`expo-camera`'s native code is discovered by `expo-modules-autolinking`, not by RN's own
+`react-native.config.cjs` mechanism. Wire it into the native host app **once**, it covers this package
+and every other `expo-modules-core` package with zero further changes. The steps and the
+mechanics behind them are in the `symbiote-expo-native-module` skill and in
+[`@symbiote-native/network`](../network)'s README; the reference app is `examples/expo-react`.
+
+### Permissions
+
+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`                                   |
+
+iOS wants the microphone text even if you only take pictures, because the same view can record. Reword
+both texts to fit your app.
+
+</details>
+
+## Shape
+
+```
+src/core/                camera-view.ts - createCameraView(getNode): render, the handle (camera-view-handle.ts)
+                         and the barcode throttle. camera-api.ts - the statics of upstream's class and the
+                         permission calls. props.ts, picture-options.ts, picture-ref.ts, types.ts.
+src/react/               @symbiote-native/camera/react   - CameraView, useCameraPermissions, useMicrophonePermissions
+src/vue/                 @symbiote-native/camera/vue     - the same names
+src/svelte/              @symbiote-native/camera/svelte  - the same names ({ status, requestPermission, getPermission })
+src/solid/               @symbiote-native/camera/solid   - the same names
+src/angular/             @symbiote-native/camera/angular - CameraView, CameraPermissionsService, MicrophonePermissionsService
+```
+
+## Use it
+
+### React
+
+```tsx
+import { useRef } from 'react';
+import { CameraView, useCameraPermissions, type ICameraViewHandle } from '@symbiote-native/camera/react';
+
+const [permission, requestPermission] = useCameraPermissions();
+const camera = useRef<ICameraViewHandle>(null);
+
+return permission?.granted === true ? (
+  <>
+    <CameraView ref={camera} style={{ flex: 1 }} facing="back" />
+    <button title="Take picture" onPress={() => camera.current?.takePictureAsync({ quality: 0.8 })} />
+  </>
+) : (
+  <button title="Allow the camera" onPress={() => requestPermission()} />
+);
+```
+
+### Vue
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import { CameraView, useCameraPermissions, type ICameraViewHandle } from '@symbiote-native/camera/vue';
+
+const [permission, requestPermission] = useCameraPermissions();
+const camera = ref<ICameraViewHandle | null>(null);
+</script>
+
+<template>
+  <template v-if="permission?.granted === true">
+    <CameraView ref="camera" :style="{ flex: 1 }" facing="back" />
+    <button title="Take picture" @press="camera?.takePictureAsync({ quality: 0.8 })" />
+  </template>
+  <button v-else title="Allow the camera" @press="requestPermission()" />
+</template>
+```
+
+### Angular
+
+```ts
+import { Component, inject } from '@angular/core';
+import { SYMBIOTE_ELEMENTS } from '@symbiote-native/angular';
+import { CameraPermissionsService, CameraView } from '@symbiote-native/camera/angular';
+
+@Component({
+  standalone: true,
+  imports: [CameraView, SYMBIOTE_ELEMENTS],
+  template: `
+    @if (permission()?.granted === true) {
+      <CameraView #camera [style]="{ flex: 1 }" facing="back" />
+      <button title="Take picture" (press)="camera.takePictureAsync({ quality: 0.8 })" />
+    } @else {
+      <button title="Allow the camera" (press)="request()" />
+    }
+  `,
+})
+export class CameraCard {
+  private readonly service = inject(CameraPermissionsService);
+  readonly permission = this.service.connect();
+
+  request(): void {
+    void this.service.request();
+  }
+}
+```
+
+### Svelte
+
+```svelte
+<script lang="ts">
+  import { CameraView, useCameraPermissions, type ICameraViewHandle } from '@symbiote-native/camera/svelte';
+
+  const permission = useCameraPermissions();
+  let camera = $state<ICameraViewHandle | undefined>();
+</script>
+
+{#if permission.status?.granted === true}
+  <CameraView bind:this={camera} style={{ flex: 1 }} facing="back" />
+  <button title="Take picture" onPress={() => camera?.takePictureAsync({ quality: 0.8 })} />
+{:else}
+  <button title="Allow the camera" onPress={() => permission.requestPermission()} />
+{/if}
+```
+
+### Solid
+
+```tsx
+import { Show, createSignal } from 'solid-js';
+import { CameraView, useCameraPermissions, type ICameraViewHandle } from '@symbiote-native/camera/solid';
+
+const [permission, requestPermission] = useCameraPermissions();
+const [camera, setCamera] = createSignal<ICameraViewHandle>();
+
+<Show
+  when={permission()?.granted === true}
+  fallback={<button title="Allow the camera" onPress={() => requestPermission()} />}
+>
+  <CameraView ref={setCamera} style={{ flex: 1 }} facing="back" />
+  <button title="Take picture" onPress={() => camera()?.takePictureAsync({ quality: 0.8 })} />
+</Show>;
+```
+
+## API
+
+```ts
+<CameraView facing? flash? mode? zoom? mute? enableTorch? active?   // active is iOS only
+            barcodeScannerSettings? onBarcodeScanned? onCameraReady? onMountError? ... />
+// handle: takePictureAsync, recordAsync, toggleRecordingAsync, stopRecording, pausePreview,
+//         resumePreview, getAvailablePictureSizesAsync, getAvailableLensesAsync, getSupportedFeatures
+
+isCameraAvailableAsync(): Promise<boolean>         // was CameraView.isAvailableAsync
+getAvailableVideoCodecsAsync(): Promise<ICameraVideoCodec[]>   // iOS
+launchScanner(options?): Promise<void>             dismissScanner(): Promise<void>
+onModernBarcodeScanned(listener): EventSubscription   isModernBarcodeScannerAvailable(): boolean
+scanFromURLAsync(url, barcodeTypes = ['qr']): Promise<ICameraBarcodeScanningResult[]>
+Camera.getCameraPermissionsAsync() and the three twins   // request and microphone variants
+```
+
+`PictureRef` keeps its name. Ported from upstream's `CameraView.tsx`, `Camera.ts` and `Camera.types.ts`.
+
+## Notes
+
+- **The postinstall asks for both permissions.** It writes `NSCameraUsageDescription` and
+  `NSMicrophoneUsageDescription` into `Info.plist` and `CAMERA` and `RECORD_AUDIO` into the Android
+  manifest. iOS needs the microphone text even if you only take pictures, because the same view can
+  record. Reword both texts to fit your app.
+- **Ask first, then render.** Show `CameraView` only once `useCameraPermissions` reports `granted`.
+- **`onBarcodeScanned` turns scanning on.** The scanner is enabled exactly when you pass the prop,
+  and `barcodeScannerSettings={{ barcodeTypes: [...] }}` narrows what it looks for.
+- **`CameraView` takes no children.** The native view does not host them, so draw controls and
+  frames as siblings, absolutely positioned over it.
+- **The handle works after `onCameraReady`.** `takePictureAsync` and `recordAsync` before that can
+  fail or return nothing.
+- **`active={false}` stops the camera session without unmounting the view.** iOS only, it is on by
+  default.
+- **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.
+
+## Common questions
+
+- **iOS crash when the camera opens.** A missing usage description. The postinstall writes
+  `NSCameraUsageDescription` and `NSMicrophoneUsageDescription`, iOS wants both for the camera view.
+- **Black preview.** Render the view only when permission is `granted`, test on a device (the iOS
+  Simulator has no camera) and wait for `onCameraReady` before calling the handle.
+- **The barcode callback.** Passing `onBarcodeScanned` turns the scanner on. To scan once, pass
+  `undefined` after the first result.
+- **Children.** `CameraView` takes none, upstream says to overlay a sibling with absolute
+  positioning.
+- **Mounting and unmounting freezes or crashes iOS.** Keep the view mounted and set `active={false}`
+  (iOS) to stop the session.
+- **Torch turns off at once.** Set `enableTorch` after `onCameraReady`.
+- **System scanner.** `launchScanner()`, iOS 16+ and Google's code scanner on Android.
+
+Sources: [Expo docs: Camera](https://docs.expo.dev/versions/latest/sdk/camera/),
+[expo/expo#11736](https://github.com/expo/expo/issues/11736),
+[expo/expo#16126](https://github.com/expo/expo/issues/16126),
+[expo/expo#37150](https://github.com/expo/expo/issues/37150),
+[expo/expo#34957](https://github.com/expo/expo/issues/34957),
+[expo/expo#48780](https://github.com/expo/expo/issues/48780),
+[expo/expo#36352](https://github.com/expo/expo/issues/36352).
+
+## Test it
+
+No device is needed for the logic. The core tests (`src/core/*.test.ts`) replace `expo-modules-core`
+(`requireNativeViewManager`, `Platform`) and assert the descriptor a render function returns. The
+adapter tests (`src/{react,vue,solid,angular}/**/*.test.*`, `vitest`) render the real component over the
+recording Fabric with an injected view config and assert the committed payload, and Svelte's
+`*.smoke.test.ts` compile the `.svelte` files and mount them. Painting itself is verified on a device in
+the six `examples/expo-*` canary apps (`examples/expo-react`, `examples/expo-vue-sfc`,
+`examples/expo-vue-tsx`, `examples/expo-svelte`, `examples/expo-solid`, `examples/expo-angular`), see the
+parent [README](../../README.md).
+
+The permission hooks are tested with a fake native module (`use-camera-permissions.test.*`, the Angular
+service test), the same pattern as every permission package.

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 {};