@octane-xplat/camera 0.13.0 → 0.15.0

package/types/types.d.ts

@@ -0,0 +1,290 @@
+/** Shared camera-session and movie-recording contract.
+ *
+ *  A `CameraSession` owns one camera acquisition shared between a
+ *  `CameraView` preview and at most one movie-recording attempt. Recording
+ *  settles with an immutable `MovieOutcome` only after the local movie is
+ *  finalized and its metadata is known — a returned clip is always
+ *  reopenable through `openOutput`.
+ *
+ *  This module is platform-pure: adapters implement
+ *  `CameraSessionBackend` per host. Adapters that do not support capture
+ *  yet report `supported: false` and reject `startRecording` with
+ *  `unsupportedPlatform` instead of fabricating behavior.
+ */
+/** Permission resource a `CameraSession` can inspect or request. */
+export type CameraPermissionKind = 'camera' | 'microphone';
+/** Portable authorization state. Checking never prompts. `blocked` and
+ *  `unknown` exist so hosts that cannot distinguish user denial from
+ *  policy refusal do not fabricate `restricted`. */
+export type CameraPermissionStatus = 'notDetermined' | 'granted' | 'denied' | 'restricted' | 'blocked' | 'unknown' | 'unavailable';
+/** Portable error categories. `unsupported*` covers missing host features,
+ *  devices, or capture configurations — including adapters that are not
+ *  implemented yet during staged delivery. */
+export type CameraCaptureErrorKind = 'permissionDenied' | 'permissionRestricted' | 'permissionBlocked' | 'unsupportedPlatform' | 'unsupportedConfiguration' | 'unavailable' | 'busy' | 'invalidState' | 'invalidArgument' | 'destinationUnavailable' | 'insufficientStorage' | 'noMedia' | 'captureFailed' | 'finalizationFailed' | 'storageFailed' | 'configurationMissing';
+/** Structured diagnostic carried by failures and non-fatal warnings. */
+export interface CaptureIssue {
+    kind: CameraCaptureErrorKind;
+    /** Operation being attempted, e.g. 'startRecording', 'finalize'. */
+    operation: string;
+    message: string;
+    permission?: CameraPermissionKind;
+    /** Host-specific detail for logging; never required for control flow. */
+    cause?: unknown;
+}
+/** Error thrown or settled by the session API. Satisfies `CaptureIssue`
+ *  so `error.kind` drives control flow without unwrapping. */
+export declare class CameraCaptureError extends Error implements CaptureIssue {
+    kind: CameraCaptureErrorKind;
+    operation: string;
+    permission?: CameraPermissionKind;
+    cause?: unknown;
+    constructor(issue: Omit<CaptureIssue, 'cause'> & {
+        cause?: unknown;
+    });
+}
+export type CameraFacing = 'front' | 'back';
+/** A normalized position on the live preview as the user sees it:
+ *  `{x: 0, y: 0}` is the top-left corner and `{x: 1, y: 1}` is
+ *  bottom-right, independent of sensor orientation and front-camera
+ *  mirroring. The `CameraView` `onTap` event and
+ *  `CameraSession.focusAtPoint` share this space. */
+export interface CameraPreviewPoint {
+    x: number;
+    y: number;
+}
+export type CameraOrientation = 'portrait' | 'portraitUpsideDown' | 'landscapeLeft' | 'landscapeRight' | 'unspecified';
+/** Camera selection for `CameraSessionConfig.camera`. Desktop and browser
+ *  hosts expose device identities instead of front/back semantics. */
+export type CameraSelection = 'default' | 'front' | 'back' | {
+    deviceId: string;
+};
+export interface CameraSessionConfig {
+    /** Lens or device identity. Default `'default'`: rear when available. */
+    camera?: CameraSelection;
+    /** Include an audio track; requires microphone permission. Default
+     *  false — silent capture is a deliberate app choice, never a
+     *  fallback from denied microphone access. */
+    audio?: boolean;
+    /** Capture profile. `'standard'` targets 720p at 30 fps and may select
+     *  a device-supported alternative; the started attempt discloses the
+     *  actual configuration. */
+    profile?: 'standard';
+}
+/** Resolution/frame-rate combination advertised by capability discovery.
+ *  Entries are supported combinations, not independent lists. */
+export interface CameraProfileCapability {
+    profile: 'standard';
+    width: number;
+    height: number;
+    frameRate: number;
+}
+export interface CameraDeviceInfo {
+    id: string;
+    label: string;
+    facing?: CameraFacing;
+}
+/** What the session's host can do right now. `supported: false` means the
+ *  adapter or host cannot record (reason explains); `available` reflects
+ *  current hardware/permission state and changes over time. */
+export interface CameraSessionCapabilities {
+    supported: boolean;
+    /** Why capture is unsupported or currently unavailable. */
+    reason?: string;
+    available: boolean;
+    cameras: CameraDeviceInfo[];
+    profiles: CameraProfileCapability[];
+    /** The session can add an audio track when permission allows. */
+    audio: boolean;
+    /** `focusAtPoint` can move autofocus metering on the active camera —
+     *  false on fixed-focus devices (common for front cameras) and on
+     *  platforms without point-of-interest metering. */
+    focusPointOfInterest: boolean;
+    /** `focusAtPoint` can move auto-exposure metering on the active
+     *  camera. */
+    exposurePointOfInterest: boolean;
+    /** Fixed orientations the source can lock for a take. */
+    orientations: CameraOrientation[];
+    /** `native` enforcement can still overshoot at media boundaries;
+     *  `bestEffort` limits are scheduled and may overshoot more. */
+    durationLimit: 'native' | 'bestEffort';
+    /** Where `elapsedMs` comes from while recording. */
+    elapsedTime: 'nativeMedia' | 'estimated';
+    output: {
+        mimeType: string;
+        container: string;
+        /** `appPrivateFile` output survives dispose and app restart;
+         *  `originLocal` is browser storage subject to site-data clearing. */
+        storage: 'appPrivateFile' | 'originLocal';
+        /** Accepts an app-supplied `destinationFileUrl` on start. */
+        destinationFileUrl: boolean;
+    };
+}
+export type CameraRecorderState = 'idle' | 'starting' | 'recording' | 'finalizing' | 'disposed';
+/** Frozen capture configuration reported once capture actually begins. */
+export interface EffectiveCaptureConfig {
+    cameraId: string;
+    facing?: CameraFacing;
+    audio: boolean;
+    width: number;
+    height: number;
+    frameRate: number;
+    orientation: CameraOrientation;
+    mimeType: string;
+    container: string;
+}
+export interface CameraSessionSnapshot {
+    state: CameraRecorderState;
+    /** Non-prompting last-known authorization, refreshed by `permissions()`
+     *  and `requestPermission()`. */
+    permission: Record<CameraPermissionKind, CameraPermissionStatus>;
+    /** Camera hardware/driver availability, separate from recorder state. */
+    cameraAvailable: boolean;
+    /** An active preview view is attached to this session. */
+    previewAttached: boolean;
+    interrupted: boolean;
+    attempt?: {
+        id: string;
+        state: 'starting' | 'recording' | 'finalizing';
+        elapsedMs: number;
+        configuration?: EffectiveCaptureConfig;
+    };
+}
+/** What ended a capture attempt. `interrupted` covers system suspension
+ *  and preview teardown; `previewReleased` distinguishes an app-driven
+ *  deactivation from an OS interruption. */
+export type MovieEndReason = 'stopped' | 'maximumDuration' | 'interrupted' | 'backgrounded' | 'cameraUnavailable' | 'previewReleased' | 'disposed' | 'captureError';
+/** Portable completed-output reference. `resourceId` reopens the clip
+ *  through `openOutput`; `fileUrl` additionally guarantees file-backed
+ *  native output. `synthetic` marks test-seam clips. */
+export type MovieOutput = {
+    kind: 'nativeFile';
+    resourceId: string;
+    fileUrl: string;
+    synthetic?: boolean;
+} | {
+    kind: 'browserStorage';
+    resourceId: string;
+    retention: 'persistent' | 'bestEffort';
+    synthetic?: boolean;
+};
+export interface MovieClip {
+    output: MovieOutput;
+    mimeType: string;
+    /** Authoritative duration read from the finalized movie. */
+    durationMs: number;
+    /** Presentation dimensions after the orientation transform. */
+    width: number;
+    height: number;
+    orientation: CameraOrientation;
+    /** Whether the finalized movie actually contains an audio track.
+     *  Missing requested audio is a failure, not silent capture. */
+    hasAudio: boolean;
+}
+/** One immutable terminal result per admitted attempt. `partial` marks a
+ *  usable clip ended early by an external condition — still a success;
+ *  app review decides whether to keep it. */
+export type MovieOutcome = {
+    kind: 'clip';
+    clip: MovieClip;
+    endReason: MovieEndReason;
+    partial: boolean;
+    warning?: CaptureIssue;
+} | {
+    kind: 'failed';
+    endReason: MovieEndReason;
+    stage: 'preparation' | 'capture' | 'finalization' | 'storage';
+    error: CaptureIssue;
+};
+/** Ordered lifecycle observation, correlated to an attempt when relevant. */
+export type CameraSessionEvent = {
+    type: 'stateChanged';
+    snapshot: CameraSessionSnapshot;
+} | {
+    type: 'started';
+    attemptId: string;
+    configuration: EffectiveCaptureConfig;
+} | {
+    type: 'finished';
+    attemptId: string;
+    outcome: MovieOutcome;
+} | {
+    type: 'interruption';
+    phase: 'began' | 'ended';
+    reason?: CameraInterruptionReason;
+} | {
+    type: 'availability';
+    available: boolean;
+};
+export type CameraInterruptionReason = 'background' | 'audioInUse' | 'cameraInUse' | 'multitasking' | 'systemPressure' | 'unknown';
+export interface StartRecordingOptions {
+    /** Positive finite milliseconds. Enforcement precision comes from
+     *  `capabilities().durationLimit`; the final duration is read from
+     *  the movie and may overshoot. */
+    maximumDurationMs?: number;
+    /** Fixed orientation for the take. Must appear in
+     *  `capabilities().orientations`; omit for the source default. */
+    orientation?: CameraOrientation;
+    /** App-supplied writable local `file://` URL (native hosts only,
+     *  where `capabilities().output.destinationFileUrl` is true).
+     *  Existing files are never overwritten. */
+    destinationFileUrl?: string;
+}
+/** One admitted capture attempt. `completion` is available immediately and
+ *  settles exactly once with the terminal outcome; repeated `stop()`
+ *  joins the same finalization. */
+export interface MovieTake {
+    readonly id: string;
+    readonly state: 'starting' | 'recording' | 'finalizing' | 'settled';
+    /** Elapsed capture time in milliseconds; excludes preparation and
+     *  finalization. Source identified by `capabilities().elapsedTime`. */
+    readonly elapsedMs: number;
+    readonly completion: Promise<MovieOutcome>;
+    /** Requests stop and joins finalization. Returns `completion`. */
+    stop(): Promise<MovieOutcome>;
+}
+/** Reopened access to a stored clip. `release()` frees temporary access;
+ *  it never deletes the clip. */
+export interface MovieOutputHandle {
+    /** Playable/readable location for the clip. */
+    readonly url: string;
+    readonly fileUrl?: string;
+    release(): void;
+}
+export interface CameraSession {
+    /** Non-prompting permission inspection; may return `unknown` when the
+     *  host cannot observe authorization. */
+    permissions(): Promise<Record<CameraPermissionKind, CameraPermissionStatus>>;
+    /** Runs the system authorization flow for one kind. Calls are
+     *  serialized; a status other than `notDetermined` returns without
+     *  prompting. */
+    requestPermission(kind: CameraPermissionKind): Promise<CameraPermissionStatus>;
+    capabilities(): Promise<CameraSessionCapabilities>;
+    snapshot(): CameraSessionSnapshot;
+    /** Ordered lifecycle events. A caller never loses a result by
+     *  subscribing late — `completion` is authoritative. Listener
+     *  exceptions do not change capture. */
+    subscribe(listener: (event: CameraSessionEvent) => void): () => void;
+    /** Tap-to-focus: meters one autofocus/auto-exposure pass at a
+     *  normalized preview-space point (see `CameraPreviewPoint`), pairing
+     *  with the `CameraView` `onTap` event. No-ops while no preview is
+     *  attached, after `dispose`, and on hosts without point-of-interest
+     *  metering — `capabilities()` reports `focusPointOfInterest` and
+     *  `exposurePointOfInterest` separately. Out-of-range coordinates
+     *  clamp to the preview edge; non-finite coordinates throw
+     *  `invalidArgument`. Metering is per-device state: a camera swap
+     *  through `configure` returns focus/exposure to the new device's
+     *  default. */
+    focusAtPoint(point: CameraPreviewPoint): void;
+    /** Replaces configuration while idle. Validates against current
+     *  capabilities and rejects with `invalidState` during an attempt. */
+    configure(config: Partial<CameraSessionConfig>): Promise<void>;
+    /** Admits one capture attempt. Throws `CameraCaptureError` before
+     *  admission for invalid arguments, busy, invalid state, or
+     *  unavailable camera — no attempt is created. */
+    startRecording(options?: StartRecordingOptions): MovieTake;
+    /** Reopens a stored output for playback or reading. */
+    openOutput(output: MovieOutput): Promise<MovieOutputHandle>;
+    /** Requests stop on any active attempt, awaits finalization, then
+     *  releases camera ownership. */
+    dispose(): Promise<void>;
+}

package/dist/native/CameraView.android.js

@@ -1,166 +0,0 @@
-import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
-import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
-import { cx } from "./cx.mobile.js";
-import { defineUniversalComponent, hookSlots, registerElement, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef } from "@nativescript-community/octane";
-import { Application, View } from "@nativescript/core";
-//#region src/CameraView.android.tsrx
-var _hs$ = /* @__PURE__ */ hookSlots(5);
-var _h$0 = /* @__PURE__ */ Symbol(_hs$);
-var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
-var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
-var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
-var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
-var __octaneUniversalPlan0 = universalPlan("nativescript", {
-	"kind": "host",
-	"type": "gridlayout",
-	"propsSlot": 0,
-	"children": [{
-		"kind": "host",
-		"type": "camerapreview",
-		"props": {
-			"row": 0,
-			"col": 0
-		},
-		"bindings": [["ref", 1]]
-	}]
-});
-var CameraPreview = class extends View {
-	createNativeView() {
-		const nativeClass = globalThis.com.octanexplat.camera.CameraPreviewView;
-		return new nativeClass(this._context);
-	}
-};
-registerElement("camerapreview", CameraPreview);
-var CameraView = defineUniversalComponent("nativescript", function CameraView(props) {
-	const host = useRef(null, _h$0);
-	const active = props.active !== false;
-	const facing = props.facing ?? "back";
-	useImperativeHandle(props.ref, () => ({ native: host.current.android }), [], _h$1);
-	const bindHost = useCallback((view) => {
-		host.current = view;
-	}, [], _h$2);
-	useEffect(() => {
-		const nativeView = host.current?.android;
-		if (!nativeView) return;
-		let disposed = false;
-		let provider;
-		let preview;
-		nativeView.setCameraActive(active);
-		if (!active) return () => nativeView.setCameraActive(false);
-		const fail = (message) => props.onError?.({ message });
-		if (!cameraHardwarePresent()) {
-			fail("camera unsupported");
-			return () => nativeView.setCameraActive(false);
-		}
-		ensureCameraPermission().then((granted) => {
-			if (disposed) return;
-			if (!granted) {
-				fail("camera permission denied");
-				return;
-			}
-			try {
-				const context = Application.android.context;
-				const cameraX = globalThis.androidx.camera;
-				const future = cameraX.lifecycle.ProcessCameraProvider.getInstance(context);
-				const executor = globalThis.androidx.core.content.ContextCompat.getMainExecutor(context);
-				future.addListener(new java.lang.Runnable({ run() {
-					if (disposed) return;
-					try {
-						provider = future.get();
-						const selectorClass = cameraX.core.CameraSelector;
-						const lens = facing === "front" ? selectorClass.LENS_FACING_FRONT : selectorClass.LENS_FACING_BACK;
-						const selector = new selectorClass.Builder().requireLensFacing(lens).build();
-						preview = new cameraX.core.Preview.Builder().build();
-						preview.setSurfaceProvider(nativeView.getSurfaceProvider());
-						provider.bindToLifecycle(nativeView, selector, preview);
-						props.onReady?.();
-					} catch (error) {
-						fail(error?.message ?? "camera error");
-					}
-				} }), executor);
-			} catch (error) {
-				fail(error?.message ?? "camera error");
-			}
-		});
-		return () => {
-			disposed = true;
-			nativeView.setCameraActive(false);
-			if (provider && preview) try {
-				provider.unbind(preview);
-			} catch {}
-		};
-	}, [active, facing], _h$3);
-	useEffect(() => {
-		const view = host.current;
-		if (!view) return;
-		applyEscapeProps(view.android, props);
-	}, [props.ref, props.android], _h$4);
-	return universalValue(__octaneUniversalPlan0, [universalProps([
-		[
-			"set",
-			"id",
-			props.id
-		],
-		[
-			"set",
-			"rows",
-			"*"
-		],
-		[
-			"set",
-			"columns",
-			"*"
-		],
-		[
-			"set",
-			"className",
-			cx("vx-layers", "vx-cameraview", props.className)
-		],
-		[
-			"set",
-			"style",
-			{
-				backgroundColor: "#000",
-				...props.style
-			}
-		],
-		["spread", layoutChildProps(props)],
-		[
-			"set",
-			"accessible",
-			props.accessible
-		],
-		[
-			"set",
-			"accessibilityLabel",
-			props.accessibilityLabel
-		],
-		[
-			"set",
-			"accessibilityRole",
-			nativeAccessibilityRole(props.accessibilityRole)
-		],
-		[
-			"set",
-			"accessibilityHint",
-			props.accessibilityHint
-		],
-		[
-			"set",
-			"accessibilityValue",
-			props.accessibilityValue
-		],
-		[
-			"set",
-			"accessibilityState",
-			nativeAccessibilityState(props.accessibilityState)
-		],
-		[
-			"set",
-			"accessibilityLiveRegion",
-			props.accessibilityLiveRegion
-		]
-	]), bindHost]);
-}, { "module": "@nativescript-community/octane" });
-//#endregion
-export { CameraView };

package/dist/native/CameraView.ios.js

@@ -1,131 +0,0 @@
-import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
-import { startCameraPreview } from "./camera-session.ios.js";
-import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
-import { cx } from "./cx.mobile.js";
-import { defineUniversalComponent, hookSlots, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef } from "@nativescript-community/octane";
-//#region src/CameraView.ios.tsrx
-var _hs$ = /* @__PURE__ */ hookSlots(5);
-var _h$0 = /* @__PURE__ */ Symbol(_hs$);
-var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
-var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
-var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
-var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
-var __octaneUniversalPlan0 = universalPlan("nativescript", {
-	"kind": "host",
-	"type": "gridlayout",
-	"propsSlot": 0
-});
-var CameraView = defineUniversalComponent("nativescript", function CameraView(props) {
-	const host = useRef(null, _h$0);
-	const active = props.active !== false;
-	const facing = props.facing ?? "back";
-	useImperativeHandle(props.ref, () => ({ native: host.current.ios ?? host.current.nativeViewProtected }), [], _h$1);
-	const bindHost = useCallback((view) => {
-		host.current = view;
-	}, [], _h$2);
-	useEffect(() => {
-		const view = host.current;
-		if (!view || !active) return;
-		let disposed = false;
-		let stopPreview;
-		const fail = (message) => props.onError?.({ message });
-		if (!cameraHardwarePresent()) {
-			fail("camera unsupported");
-			return;
-		}
-		ensureCameraPermission().then((granted) => {
-			if (disposed) return;
-			if (!granted) {
-				fail("camera permission denied");
-				return;
-			}
-			try {
-				stopPreview = startCameraPreview(view, facing, props.onReady);
-			} catch (error) {
-				fail(error?.message ?? "camera error");
-			}
-		});
-		return () => {
-			disposed = true;
-			stopPreview?.();
-		};
-	}, [active, facing], _h$3);
-	useEffect(() => {
-		const view = host.current;
-		if (!view) return;
-		applyEscapeProps(view.ios ?? view.nativeViewProtected, props);
-	}, [props.ref, props.ios], _h$4);
-	return universalValue(__octaneUniversalPlan0, [universalProps([
-		[
-			"set",
-			"ref",
-			bindHost
-		],
-		[
-			"set",
-			"id",
-			props.id
-		],
-		[
-			"set",
-			"rows",
-			"*"
-		],
-		[
-			"set",
-			"columns",
-			"*"
-		],
-		[
-			"set",
-			"className",
-			cx("vx-layers", "vx-cameraview", props.className)
-		],
-		[
-			"set",
-			"style",
-			{
-				backgroundColor: "#000",
-				...props.style
-			}
-		],
-		["spread", layoutChildProps(props)],
-		[
-			"set",
-			"accessible",
-			props.accessible
-		],
-		[
-			"set",
-			"accessibilityLabel",
-			props.accessibilityLabel
-		],
-		[
-			"set",
-			"accessibilityRole",
-			nativeAccessibilityRole(props.accessibilityRole)
-		],
-		[
-			"set",
-			"accessibilityHint",
-			props.accessibilityHint
-		],
-		[
-			"set",
-			"accessibilityValue",
-			props.accessibilityValue
-		],
-		[
-			"set",
-			"accessibilityState",
-			nativeAccessibilityState(props.accessibilityState)
-		],
-		[
-			"set",
-			"accessibilityLiveRegion",
-			props.accessibilityLiveRegion
-		]
-	])]);
-}, { "module": "@nativescript-community/octane" });
-//#endregion
-export { CameraView };

package/dist/native/camera-permission.mobile.js

@@ -1,45 +0,0 @@
-import { Application, isAndroid, isIOS } from "@nativescript/core";
-//#region src/camera-permission.mobile.ts
-var requestCode = 7719;
-function cameraHardwarePresent() {
-	if (isIOS) return typeof globalThis.AVCaptureDevice !== "undefined";
-	if (!isAndroid) return false;
-	try {
-		return (Application.android?.context ?? Application.android?.startActivity)?.getPackageManager()?.hasSystemFeature("android.hardware.camera.any") !== false;
-	} catch {
-		return true;
-	}
-}
-async function ensureCameraPermission() {
-	try {
-		if (isIOS) {
-			const av = globalThis.AVCaptureDevice;
-			const mediaType = globalThis.AVMediaTypeVideo ?? "vide";
-			const status = av?.authorizationStatusForMediaType?.(mediaType);
-			if (status === 3) return true;
-			if (status === 1 || status === 2) return false;
-			return await new Promise((resolve) => av.requestAccessForMediaTypeCompletionHandler(mediaType, resolve));
-		}
-		if (isAndroid) {
-			const permission = "android.permission.CAMERA";
-			const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
-			if (activity?.checkSelfPermission?.(permission) === android.content.pm.PackageManager.PERMISSION_GRANTED) return true;
-			if (!activity) return false;
-			return await new Promise((resolve) => {
-				const currentRequest = requestCode++;
-				const onResult = (args) => {
-					if (args.requestCode !== currentRequest) return;
-					Application.android.off(Application.android.activityRequestPermissionsEvent, onResult);
-					resolve(args.grantResults?.[0] === android.content.pm.PackageManager.PERMISSION_GRANTED);
-				};
-				Application.android.on(Application.android.activityRequestPermissionsEvent, onResult);
-				activity.requestPermissions([permission], currentRequest);
-			});
-		}
-	} catch {
-		return false;
-	}
-	return false;
-}
-//#endregion
-export { cameraHardwarePresent, ensureCameraPermission };

package/dist/native/camera-session.ios.js

@@ -1,45 +0,0 @@
-//#region src/camera-session.ios.ts
-/** Attach an AVFoundation preview layer to a NativeScript UIView host. */
-function startCameraPreview(view, facing, onReady) {
-	const av = globalThis;
-	const mediaType = av.AVMediaTypeVideo ?? "vide";
-	const desiredPosition = facing === "front" ? av.AVCaptureDevicePositionFront ?? 2 : av.AVCaptureDevicePositionBack ?? 1;
-	const devices = av.AVCaptureDevice.devicesWithMediaType(mediaType);
-	let device = null;
-	for (let index = 0; index < devices.count; index++) {
-		const candidate = devices.objectAtIndex(index);
-		if (candidate.position === desiredPosition) {
-			device = candidate;
-			break;
-		}
-	}
-	if (!device) throw new Error("camera unavailable");
-	const session = av.AVCaptureSession.new();
-	const input = av.AVCaptureDeviceInput.deviceInputWithDeviceError(device);
-	if (!input || !session.canAddInput(input)) throw new Error("camera input unavailable");
-	session.addInput(input);
-	const layer = av.AVCaptureVideoPreviewLayer.layerWithSession(session);
-	layer.videoGravity = "resizeAspectFill";
-	const connection = layer.connection;
-	if (connection) {
-		connection.automaticallyAdjustsVideoMirroring = false;
-		if (connection.isVideoMirroringSupported) connection.isVideoMirrored = facing === "front";
-	}
-	const nativeView = view.ios ?? view.nativeViewProtected;
-	if (!nativeView?.layer) throw new Error("camera preview host unavailable");
-	nativeView.layer.addSublayer(layer);
-	const updateFrame = () => {
-		layer.frame = nativeView.bounds;
-	};
-	view.on?.("layoutChanged", updateFrame);
-	updateFrame();
-	session.startRunning();
-	onReady?.();
-	return () => {
-		view.off?.("layoutChanged", updateFrame);
-		session.stopRunning();
-		layer.removeFromSuperlayer();
-	};
-}
-//#endregion
-export { startCameraPreview };

package/dist/native/cx.mobile.js

@@ -1,9 +0,0 @@
-//#region src/cx.mobile.ts
-/** Imperative `view.className` writes still need a pre-joined string —
-* NativeScript's className setter splits on ' ' only. Normalize arrays here
-* so they stay space separated. */
-function cx(...parts) {
-	return parts.flat(Infinity).filter(Boolean).join(" ");
-}
-//#endregion
-export { cx };

package/dist/native/index.js

@@ -1,2 +0,0 @@
-import { CameraView } from "./src/CameraView";
-export { CameraView };