@octane-xplat/camera 0.13.0 → 0.14.0

package/src/index.web.ts

@@ -1,2 +1,33 @@
 export { CameraView } from './CameraView.web.tsrx'
 export type { CameraAccessibilityRole, CameraViewHandle, CameraViewProps } from './props'
+export { createCameraSession } from './session'
+export { CameraCaptureError } from './types'
+export type {
+	CameraCaptureErrorKind,
+	CameraDeviceInfo,
+	CameraFacing,
+	CameraInterruptionReason,
+	CameraOrientation,
+	CameraPermissionKind,
+	CameraPermissionStatus,
+	CameraProfileCapability,
+	CameraRecorderState,
+	CameraSelection,
+	CameraSession,
+	CameraSessionCapabilities,
+	CameraSessionConfig,
+	CameraSessionEvent,
+	CameraSessionSnapshot,
+	CaptureIssue,
+	EffectiveCaptureConfig,
+	MovieClip,
+	MovieEndReason,
+	MovieOutcome,
+	MovieOutput,
+	MovieOutputHandle,
+	MovieTake,
+	StartRecordingOptions,
+} from './types'
+
+export { createMemoryCameraStorage, createSyntheticCameraSession } from './synthetic-session'
+export type { SyntheticCameraScript, SyntheticCameraStorage } from './synthetic-session'

package/src/layout-child.windows.ts

@@ -0,0 +1,79 @@
+import type { CameraViewProps } from './props'
+
+/** 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. */
+
+export function layoutChildProps(props: CameraViewProps): Record<string, any> {
+	const result: Record<string, any> = {}
+	for (const key of [
+		'row',
+		'col',
+		'rowSpan',
+		'colSpan',
+		'dock',
+		'left',
+		'top',
+		'flexGrow',
+		'flexShrink',
+		'alignSelf',
+		'order',
+	] as const) {
+		if (props[key] !== undefined) {
+			result[key] = props[key]
+		}
+	}
+
+	return result
+}
+
+export function applyEscapeProps(view: any, props: { windows?: any }): void {
+	if (view && props.windows) {
+		Object.assign(view, props.windows)
+	}
+}
+
+const nativeRoles: Record<string, string> = {
+	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',
+}
+
+export function nativeAccessibilityRole(role?: string): string | undefined {
+	return role ? nativeRoles[role] : undefined
+}
+
+export function nativeAccessibilityState(
+	state?: CameraViewProps['accessibilityState'],
+): string | undefined {
+	if (state?.disabled) {
+		return 'disabled'
+	}
+
+	if (state?.selected) {
+		return 'selected'
+	}
+
+	if (state?.checked === true) {
+		return 'checked'
+	}
+
+	if (state?.checked === false) {
+		return 'unchecked'
+	}
+
+	return undefined
+}

package/src/movie-metadata.web.ts

@@ -0,0 +1,84 @@
+import { BlobSource, Input, MP4, WEBM } from 'mediabunny'
+import { CameraCaptureError } from './types'
+
+/** Read packet end timestamps and track metadata, never the wall-clock stop time. */
+export async function inspectMovie(bytes: Blob, audioRequested: boolean) {
+	if (!bytes.size) {
+		throw new CameraCaptureError({
+			kind: 'noMedia',
+			operation: 'finalize',
+			message: 'The recorder produced no movie bytes',
+		})
+	}
+
+	const input = new Input({ source: new BlobSource(bytes), formats: [WEBM, MP4] })
+	const read = async () => {
+		const video = await input.getPrimaryVideoTrack()
+		const audio = await input.getPrimaryAudioTrack()
+		if (!video) {
+			throw new CameraCaptureError({
+				kind: 'noMedia',
+				operation: 'finalize',
+				message: 'The movie contains no video track',
+			})
+		}
+
+		const videoDuration = await video.computeDuration()
+		const hasAudio = audio !== null && (await audio.computeDuration()) > 0
+		const durationMs = (await input.computeDuration()) * 1000
+		const width = await video.getDisplayWidth()
+		const height = await video.getDisplayHeight()
+		if (
+			!Number.isFinite(durationMs) ||
+			durationMs <= 0 ||
+			videoDuration <= 0 ||
+			width <= 0 ||
+			height <= 0
+		) {
+			throw new CameraCaptureError({
+				kind: 'noMedia',
+				operation: 'finalize',
+				message: 'The movie has no usable video media',
+			})
+		}
+
+		if (audioRequested && !hasAudio) {
+			throw new CameraCaptureError({
+				kind: 'captureFailed',
+				operation: 'finalize',
+				message: 'Requested audio is absent from the finalized movie',
+			})
+		}
+
+		return {
+			durationMs,
+			width,
+			height,
+			hasAudio,
+			mimeType: await input.getMimeType(),
+			orientation: 'unspecified' as const,
+		}
+	}
+
+	let timer: ReturnType<typeof setTimeout> | undefined
+	try {
+		return await Promise.race([
+			read(),
+			new Promise<never>((_resolve, reject) => {
+				timer = setTimeout(() => {
+					input.dispose()
+					reject(
+						new CameraCaptureError({
+							kind: 'finalizationFailed',
+							operation: 'metadata',
+							message: 'Movie metadata verification timed out',
+						}),
+					)
+				}, 30_000)
+			}),
+		])
+	} finally {
+		clearTimeout(timer)
+		input.dispose()
+	}
+}

package/src/movie-storage.web.ts

@@ -0,0 +1,164 @@
+import { CameraCaptureError } from './types'
+import type { MovieClip, MovieOutput, MovieOutputHandle } from './types'
+
+const databaseName = 'octane-xplat-camera'
+const storeName = 'movies'
+
+type StoredMovie = { id: string; clip?: MovieClip; bytes?: Blob }
+
+const storageError = (cause: unknown) =>
+	new CameraCaptureError({
+		kind:
+			cause instanceof DOMException && cause.name === 'QuotaExceededError'
+				? 'insufficientStorage'
+				: 'storageFailed',
+		operation: 'storage',
+		message: 'The movie could not be committed to origin-local storage',
+		cause,
+	})
+
+/** Each operation closes its database; playback survives session and page lifetimes. */
+async function transact<T>(
+	mode: IDBTransactionMode,
+	operation: (store: IDBObjectStore, result: (value: T) => void) => void,
+): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+		let database: IDBDatabase | undefined
+		let transaction: IDBTransaction | undefined
+		let result: T
+		let done = false
+		const finish = (cause?: unknown) => {
+			if (done) {
+				return
+			}
+
+			done = true
+			clearTimeout(timer)
+			database?.close()
+			if (cause) {
+				reject(storageError(cause))
+			} else {
+				resolve(result)
+			}
+		}
+
+		const timer = setTimeout(() => {
+			transaction?.abort()
+			finish(new Error('Storage transaction timed out'))
+		}, 15_000)
+
+		const request = indexedDB.open(databaseName, 1)
+		request.onupgradeneeded = () => request.result.createObjectStore(storeName, { keyPath: 'id' })
+		request.onerror = () => finish(request.error)
+		request.onblocked = () => finish(new Error('Storage upgrade is blocked by another page'))
+		request.onsuccess = () => {
+			database = request.result
+			if (done) {
+				database.close()
+				return
+			}
+
+			try {
+				transaction = database.transaction(storeName, mode, { durability: 'strict' })
+				transaction.oncomplete = () => finish()
+				transaction.onabort = () =>
+					finish(transaction?.error ?? new Error('Storage transaction aborted'))
+
+				transaction.onerror = () =>
+					finish(transaction?.error ?? new Error('Storage transaction failed'))
+
+				operation(transaction.objectStore(storeName), (value) => {
+					result = value
+				})
+			} catch (cause) {
+				finish(cause)
+			}
+		}
+	})
+}
+
+export async function reserveMovie(): Promise<string> {
+	const estimate = await navigator.storage.estimate()
+	if (
+		estimate.quota !== undefined &&
+		estimate.usage !== undefined &&
+		estimate.quota - estimate.usage < 1_048_576
+	) {
+		throw new CameraCaptureError({
+			kind: 'insufficientStorage',
+			operation: 'reserve',
+			message: 'Origin storage has less than 1 MiB free',
+		})
+	}
+
+	const id = crypto.randomUUID()
+	await transact<void>('readwrite', (store) => {
+		store.add({ id })
+	})
+
+	return id
+}
+
+export async function commitMovie(id: string, bytes: Blob, clip: MovieClip): Promise<void> {
+	if (!(await navigator.storage.persisted())) {
+		throw new CameraCaptureError({
+			kind: 'destinationUnavailable',
+			operation: 'storage',
+			message: 'Persistent origin storage is no longer granted',
+		})
+	}
+
+	await transact<void>('readwrite', (store) => {
+		store.put({ id, bytes, clip } satisfies StoredMovie)
+	})
+
+	// Reopen the committed entry before handing ownership to the app.
+	const stored = await readMovie(id)
+	if (!stored.bytes || stored.bytes.size !== bytes.size || !stored.clip) {
+		throw storageError(new Error('Committed movie cannot be reopened'))
+	}
+}
+
+export async function removeReservation(id: string): Promise<void> {
+	await transact<void>('readwrite', (store) => {
+		store.delete(id)
+	})
+}
+
+async function readMovie(id: string): Promise<StoredMovie> {
+	return transact<StoredMovie>('readonly', (store, result) => {
+		const request = store.get(id)
+		request.onsuccess = () => result(request.result ?? { id })
+	})
+}
+
+export async function openStoredMovie(output: MovieOutput): Promise<MovieOutputHandle> {
+	if (output.kind !== 'browserStorage' || output.synthetic) {
+		throw new CameraCaptureError({
+			kind: 'invalidArgument',
+			operation: 'openOutput',
+			message: 'Expected an origin-local movie reference',
+		})
+	}
+
+	const stored = await readMovie(output.resourceId)
+	if (!stored.bytes || !stored.clip) {
+		throw new CameraCaptureError({
+			kind: 'destinationUnavailable',
+			operation: 'openOutput',
+			message: 'Movie is missing or site data was cleared',
+		})
+	}
+
+	const url = URL.createObjectURL(stored.bytes)
+	let released = false
+	return {
+		url,
+		release: () => {
+			if (!released) {
+				released = true
+				URL.revokeObjectURL(url)
+			}
+		},
+	}
+}

package/src/props.ts

@@ -1,4 +1,5 @@
 import type { Octane } from 'octane/jsx-runtime'
+import type { CameraSession } from './types'
 
 export type CameraAccessibilityRole =
 	| 'button'
@@ -48,7 +49,11 @@ export interface CameraViewProps {
 		checked?: boolean
 	}
 	accessibilityLiveRegion?: 'none' | 'polite' | 'assertive'
-	/** Lens — defaults to the rear camera. */
+	/** Shared camera owner enabling movie recording. When set, the preview
+	 *  attaches to the session's acquisition instead of owning one, and
+	 *  `facing` must be omitted — camera selection lives on the session. */
+	session?: CameraSession
+	/** Lens — defaults to the rear camera. Invalid together with `session`. */
 	facing?: 'front' | 'back'
 	/** Default true. False releases the preview session. */
 	active?: boolean
@@ -61,4 +66,5 @@ export interface CameraViewProps {
 	ios?: Record<string, any>
 	android?: Record<string, any>
 	web?: Record<string, any>
+	windows?: Record<string, any>
 }