@octane-xplat/camera 0.12.0 → 0.14.0

package/dist/native/CameraView.android.js

@@ -1,3 +1,4 @@
+import { attachSessionPreview } from "./session.js";
 import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
 import { cx } from "./cx.mobile.js";
@@ -48,6 +49,25 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 		nativeView.setCameraActive(active);
 		if (!active) return () => nativeView.setCameraActive(false);
 		const fail = (message) => props.onError?.({ message });
+		if (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return () => nativeView.setCameraActive(false);
+			}
+			try {
+				const detach = attachSessionPreview(props.session, nativeView, {
+					onReady: props.onReady,
+					onError: (issue) => fail(issue.message)
+				});
+				return () => {
+					detach();
+					nativeView.setCameraActive(false);
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return () => nativeView.setCameraActive(false);
+			}
+		}
 		if (!cameraHardwarePresent()) {
 			fail("camera unsupported");
 			return () => nativeView.setCameraActive(false);
@@ -89,7 +109,11 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 				provider.unbind(preview);
 			} catch {}
 		};
-	}, [active, facing], _h$3);
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
 	useEffect(() => {
 		const view = host.current;
 		if (!view) return;

package/dist/native/CameraView.ios.js

@@ -1,3 +1,4 @@
+import { attachSessionPreview } from "./session.js";
 import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
 import { startCameraPreview } from "./camera-session.ios.js";
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
@@ -29,6 +30,24 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 		let disposed = false;
 		let stopPreview;
 		const fail = (message) => props.onError?.({ message });
+		if (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return;
+			}
+			try {
+				const detach = attachSessionPreview(props.session, view, { onReady: () => {
+					if (!disposed) props.onReady?.();
+				} });
+				return () => {
+					disposed = true;
+					detach();
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return;
+			}
+		}
 		if (!cameraHardwarePresent()) {
 			fail("camera unsupported");
 			return;
@@ -49,7 +68,11 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 			disposed = true;
 			stopPreview?.();
 		};
-	}, [active, facing], _h$3);
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
 	useEffect(() => {
 		const view = host.current;
 		if (!view) return;

package/dist/native/CameraView.windows.js

@@ -0,0 +1,173 @@
+import { attachSessionPreview } from "./session.js";
+import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.windows.js";
+import { startCameraPreview } from "./camera-session.windows.js";
+import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.windows.js";
+import { cx } from "./cx.windows.js";
+import { defineUniversalComponent, hookSlots, registerElement, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef } from "@nativescript-community/octane";
+import { View } from "@nativescript/core";
+//#region src/CameraView.windows.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 { Microsoft } = globalThis;
+		return new Microsoft.UI.Xaml.Controls.CaptureElement();
+	}
+};
+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?.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 (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return;
+			}
+			try {
+				const detach = attachSessionPreview(props.session, view, {
+					onReady: () => {
+						if (!disposed) props.onReady?.();
+					},
+					onError: (issue) => {
+						if (!disposed) fail(issue.message);
+					}
+				});
+				return () => {
+					disposed = true;
+					detach();
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return;
+			}
+		}
+		if (!cameraHardwarePresent()) {
+			fail("camera unsupported");
+			return;
+		}
+		ensureCameraPermission().then(async (granted) => {
+			if (disposed) return;
+			if (!granted) {
+				fail("camera permission denied");
+				return;
+			}
+			try {
+				stopPreview = await startCameraPreview(view, facing, () => {
+					if (!disposed) props.onReady?.();
+				});
+			} catch (error) {
+				if (!disposed) fail(error?.message ?? "camera error");
+			}
+		});
+		return () => {
+			disposed = true;
+			stopPreview?.();
+		};
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
+	useEffect(() => {
+		const view = host.current;
+		if (!view) return;
+		applyEscapeProps(view.nativeViewProtected, props);
+	}, [props.ref, props.windows], _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/camera-permission.windows.js

@@ -0,0 +1,43 @@
+//#region src/camera-permission.windows.ts
+/** Windows camera-permission probe for preview-only `CameraView` callers.
+*  Uses `AppCapability` when projected and falls back to
+*  `DeviceAccessInformation`; both are non-prompting checks — only
+*  `RequestAccessAsync` may show the system prompt. */
+var windows = () => globalThis;
+var toPromise = (op) => {
+	const { NSWinRT } = windows();
+	if (NSWinRT?.toPromise && op != null) return NSWinRT.toPromise(op);
+	if (op?.done) return new Promise((resolve, reject) => {
+		try {
+			op.done(resolve, reject);
+		} catch (cause) {
+			reject(cause);
+		}
+	});
+	return Promise.resolve(op);
+};
+function cameraHardwarePresent() {
+	const { Windows, Microsoft } = windows();
+	return !!(Windows?.Media?.Capture?.MediaCapture && Windows?.Devices?.Enumeration?.DeviceInformation && Microsoft?.UI?.Xaml?.Controls?.CaptureElement);
+}
+async function ensureCameraPermission() {
+	try {
+		const { Windows } = windows();
+		const capability = Windows?.Security?.Authorization?.AppCapabilityAccess?.AppCapability?.Create?.("webcam");
+		if (capability) {
+			const status = capability.CheckAccess();
+			if (status === 4) return true;
+			if (status === 3) return await toPromise(capability.RequestAccessAsync()) === 4;
+			return false;
+		}
+		const enumeration = Windows?.Devices?.Enumeration;
+		const deviceClass = enumeration?.DeviceClass?.VideoCapture;
+		const info = deviceClass === void 0 ? void 0 : enumeration?.DeviceAccessInformation?.CreateFromDeviceClass(deviceClass);
+		if (info) return info.CurrentStatus !== 2 && info.CurrentStatus !== 3;
+	} catch {
+		return false;
+	}
+	return false;
+}
+//#endregion
+export { cameraHardwarePresent, ensureCameraPermission };

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

@@ -0,0 +1,78 @@
+//#region src/camera-session.windows.ts
+/** Standalone (non-session) WinUI preview for `CameraView` without a
+*  `session` prop. Owns a private `MediaCapture` bound to a
+*  `CaptureElement`; the returned function stops preview and closes the
+*  device. Session-backed previews share their capture through
+*  `session-backend.windows.ts` instead. */
+var windows = () => globalThis;
+var toPromise = (op) => {
+	const { NSWinRT } = windows();
+	if (NSWinRT?.toPromise && op != null) return NSWinRT.toPromise(op);
+	if (op?.done) return new Promise((resolve, reject) => {
+		try {
+			op.done(resolve, reject);
+		} catch (cause) {
+			reject(cause);
+		}
+	});
+	return Promise.resolve(op);
+};
+var vectorToArray = (items) => {
+	const result = [];
+	const size = Number(items?.Size ?? items?.Count ?? 0);
+	for (let index = 0; index < size; index += 1) result.push(items.GetAt(index));
+	return result;
+};
+/** Attach a MediaCapture preview to the view's `CaptureElement`.
+*  `facing` maps to enclosure panels; desktop cameras without a panel fall
+*  back to the OS default — front/back is a preference, never a fabrication. */
+async function startCameraPreview(view, facing, onReady) {
+	const { Windows } = windows();
+	const enumeration = Windows?.Devices?.Enumeration;
+	const captureApi = Windows?.Media?.Capture;
+	if (!enumeration || !captureApi) throw new Error("camera preview unsupported");
+	const devices = vectorToArray(await toPromise(enumeration.DeviceInformation.FindAllAsync(enumeration.DeviceClass.VideoCapture)));
+	if (!devices.length) throw new Error("camera unavailable");
+	const wantedPanel = facing === "front" ? 1 : 2;
+	const device = devices.find((entry) => Number(entry?.EnclosureLocation?.Panel) === wantedPanel) ?? devices[0];
+	const settings = new captureApi.MediaCaptureInitializationSettings();
+	settings.VideoDeviceId = String(device?.Id ?? device?.id ?? "");
+	settings.StreamingCaptureMode = 0;
+	const capture = new captureApi.MediaCapture();
+	try {
+		await toPromise(capture.InitializeAsync(settings));
+	} catch (cause) {
+		try {
+			capture.Close();
+		} catch {
+			try {
+				capture.Dispose();
+			} catch {}
+		}
+		throw cause instanceof Error ? cause : /* @__PURE__ */ new Error("camera unavailable");
+	}
+	const element = view?.nativeViewProtected ?? view;
+	element.Source = capture;
+	try {
+		if (Number(device?.EnclosureLocation?.Panel) === 1 && typeof capture.SetPreviewMirroring === "function") capture.SetPreviewMirroring(true);
+	} catch {}
+	await toPromise(capture.StartPreviewAsync());
+	onReady?.();
+	return async () => {
+		try {
+			element.Source = null;
+		} catch {}
+		try {
+			await toPromise(capture.StopPreviewAsync());
+		} catch {}
+		try {
+			capture.Close();
+		} catch {
+			try {
+				capture.Dispose();
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { startCameraPreview };

package/dist/native/cx.mobile.js

@@ -1,6 +1,7 @@
 //#region src/cx.mobile.ts
-/** NativeScript's universal driver stringifies className values; normalize
-* arrays here so they stay space separated. */
+/** 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(" ");
 }

package/dist/native/cx.windows.js

@@ -0,0 +1,9 @@
+//#region src/cx.windows.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 +1,5 @@
+import { CameraCaptureError } from "./types.js";
+import { createCameraSession } from "./session.js";
+import { createMemoryCameraStorage, createSyntheticCameraSession } from "./synthetic-session.js";
 import { CameraView } from "./src/CameraView";
-export { CameraView };
+export { CameraCaptureError, CameraView, createCameraSession, createMemoryCameraStorage, createSyntheticCameraSession };

package/dist/native/layout-child.windows.js

@@ -0,0 +1,53 @@
+//#region src/layout-child.windows.ts
+/** Windows twins of the layout-child helpers — the unsuffixed module
+*  resolves the platform escape bag through `isIOS`, which has no Windows
+*  branch. Pure helpers are re-declared here to keep divergence at the file
+*  boundary. */
+function layoutChildProps(props) {
+	const result = {};
+	for (const key of [
+		"row",
+		"col",
+		"rowSpan",
+		"colSpan",
+		"dock",
+		"left",
+		"top",
+		"flexGrow",
+		"flexShrink",
+		"alignSelf",
+		"order"
+	]) if (props[key] !== void 0) result[key] = props[key];
+	return result;
+}
+function applyEscapeProps(view, props) {
+	if (view && props.windows) Object.assign(view, props.windows);
+}
+var nativeRoles = {
+	button: "button",
+	link: "link",
+	search: "search",
+	image: "image",
+	heading: "header",
+	adjustable: "adjustable",
+	summary: "summary",
+	text: "text",
+	none: "none",
+	progressbar: "progressBar",
+	checkbox: "checkbox",
+	switch: "switch",
+	radio: "radioButton",
+	spinbutton: "spinButton",
+	tab: "button"
+};
+function nativeAccessibilityRole(role) {
+	return role ? nativeRoles[role] : void 0;
+}
+function nativeAccessibilityState(state) {
+	if (state?.disabled) return "disabled";
+	if (state?.selected) return "selected";
+	if (state?.checked === true) return "checked";
+	if (state?.checked === false) return "unchecked";
+}
+//#endregion
+export { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState };

package/dist/native/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "1a1245b9-3adb-450e-8ff6-da9f7fe2b58c",
+  "buildId": "1f1a64b1-cefc-4981-aaa1-ec37fe3f7c71",
   "mode": "production",
   "capabilities": {
     "independentHydration": false