@incodetech/core 2.0.0-alpha.10 → 2.0.0-alpha.12

package/dist/selfie.esm.js

@@ -1,7 +1,9 @@
-import { n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-I6vX6DBy.esm.js";
-import { c as FaceDetectionProvider, d as StreamCanvasProcessingSession, f as StreamCanvasCapture, g as createManager, h as stopCameraStream, m as requestCameraAccess, n as api, s as WasmUtilProvider, t as endpoints, u as OpenViduRecordingProvider } from "./endpoints-BSTFaHYo.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
-import { t as addEvent } from "./addEvent-W0ORK0jT.esm.js";
+import { E as createManager, T as stopCameraStream, f as FaceDetectionProvider, h as OpenViduRecordingProvider, i as getToken, n as api, t as endpoints, u as WasmUtilProvider, v as StreamCanvasProcessingSession, w as requestCameraAccess, y as StreamCanvasCapture } from "./endpoints-D9TGnxRK.esm.js";
+import { n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-D5MURoVB.esm.js";
+import { i as getDeviceClass, n as checkPermission, r as requestPermission, t as streamingEvents } from "./streamingEvents-B3hNanPl.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-2hDiAXvZ.esm.js";
+import { t as addEvent } from "./addEvent-BGKc_lHF.esm.js";
+import "./deepsightService-BWxcc4OC.esm.js";
 
 //#region src/modules/selfie/types.ts
 const FACE_ERROR_CODES = {
@@ -55,53 +57,25 @@ const validateUploadResponse = ({ config, response }) => {
 	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
 };
 
-//#endregion
-//#region src/internal/recordings/recordingsRepository.ts
-async function createRecordingSession(type) {
-	return (await api.post(endpoints.recordingCreateSessionV2, { type })).data;
-}
-async function startRecording(params) {
-	return (await api.post(endpoints.recordingStartV2, {
-		videoRecordingId: params.videoRecordingId,
-		frameRate: 30,
-		outputMode: "COMPOSED",
-		resolution: params.resolution,
-		type: params.type,
-		hasAudio: params.hasAudio ?? false
-	})).data;
-}
-async function stopRecording$1(videoRecordingId) {
-	return (await api.post(endpoints.recordingStopV2, { videoRecordingId })).data;
-}
-
-//#endregion
-//#region src/internal/recordings/streamingEvents.ts
-const streamingEvents = {
-	strSessionDidConnect: "strSessionDidConnect",
-	strSessionDidDisconnect: "strSessionDidDisconnect",
-	strSessionDidFailWithError: "strSessionDidFailWithError",
-	strStreamVideoCaptureStart: "strStreamVideoCaptureStart",
-	strStreamVideoCaptureStop: "strStreamVideoCaptureStop",
-	strStreamPublisherCreated: "strStreamPublisherCreated",
-	strStreamPublisherDestroyed: "strStreamPublisherDestroyed",
-	strStreamPublisherDidFailWithError: "strStreamPublisherDidFailWithError"
-};
-
 //#endregion
 //#region src/modules/selfie/selfieUploadService.ts
 /**
 * Uploads a selfie image to the backend.
 */
-async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal }) {
+async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
 	try {
-		const res = await api.post(endpoints.selfie, {
+		const payload = {
 			base64Image: encryptedBase64Image,
 			faceCoordinates: faceCoordinates ?? void 0,
 			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() }
-		}, {
+			clientInfo: { deviceClass: getDeviceClass() },
+			metadata: metadata ?? void 0
+		};
+		const query = { imageType: "selfie" };
+		if (recordingId) query.recordingId = recordingId;
+		const res = await api.post(endpoints.selfie, payload, {
 			signal,
-			query: { imageType: "selfie" }
+			query
 		});
 		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
 		return res.data;
@@ -127,6 +101,12 @@ const getFaceErrorCodeFromHttpError = (error) => {
 		4078: FACE_ERROR_CODES.FACE_OCCLUDED
 	}[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
 };
+async function processFace(imageType = "selfie", signal) {
+	return (await api.post(endpoints.processFace, {}, {
+		query: { imageType },
+		signal
+	})).data;
+}
 
 //#endregion
 //#region src/modules/selfie/selfieServices.ts
@@ -249,6 +229,7 @@ function buildResolutionFromStream(stream) {
 	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
 }
 async function startRecordingSession(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
 	if (params.config.enableFaceRecording !== true) return;
 	if (params.existing) return params.existing;
 	const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
@@ -371,6 +352,11 @@ function stopRecording(session) {
 		}
 	})();
 }
+async function initializeDeepsightSession(config) {
+	if (config.deepsightLiveness !== "VIDEOLIVENESS") return;
+	const { loadDeepsightSession } = await import("./deepsightLoader-B36_XZ7r.esm.js");
+	return loadDeepsightSession();
+}
 
 //#endregion
 //#region src/modules/selfie/selfieStateMachine.ts
@@ -422,10 +408,26 @@ const _selfieMachine = setup({
 			});
 			return cleanup;
 		}),
+		initializeDeepsightSession: fromPromise(async ({ input }) => {
+			return await initializeDeepsightSession(input.config);
+		}),
 		uploadSelfie: fromPromise(async ({ input, signal }) => {
+			let metadata;
+			let recordingId = null;
+			if (input.deepsightService) {
+				const imageData = input.canvas.getImageData();
+				const sessionToken = getToken();
+				if (imageData && sessionToken) {
+					const result = await input.deepsightService.performCapture(sessionToken, imageData);
+					metadata = result.metadata;
+					recordingId = result.recordingId;
+				}
+			}
 			return uploadSelfie({
 				encryptedBase64Image: await encryptSelfieImage({ canvas: input.canvas }),
 				faceCoordinates: input.faceCoordinates,
+				metadata,
+				recordingId,
 				signal
 			});
 		}),
@@ -436,6 +438,9 @@ const _selfieMachine = setup({
 				clonedStream: input.clonedStream,
 				existing: input.existing
 			});
+		}),
+		processFace: fromPromise(async ({ signal }) => {
+			return processFace("selfie", signal);
 		})
 	},
 	actions: {
@@ -479,12 +484,14 @@ const _selfieMachine = setup({
 			capturedImage: void 0,
 			faceCoordinates: void 0,
 			uploadResponse: void 0,
+			processResponse: void 0,
 			recordingSession: void 0,
 			recordingStream: void 0,
 			attemptsRemaining: context.config.captureAttempts,
 			uploadError: void 0,
 			permissionResult: void 0,
-			resetDetection: void 0
+			resetDetection: void 0,
+			deepsightService: void 0
 		})),
 		resetDetection: ({ context }) => {
 			context.resetDetection?.();
@@ -520,6 +527,20 @@ const _selfieMachine = setup({
 		} }),
 		stopRecordingStream: ({ context }) => {
 			if (context.recordingStream) stopStream(context.recordingStream);
+		},
+		startDeepsightRecording: ({ context }) => {
+			if (context.deepsightService && context.stream) context.deepsightService.startRecording(context.stream);
+		},
+		checkVirtualCamera: ({ context }) => {
+			(async () => {
+				if (context.deepsightService && context.stream) {
+					const videoTrack = context.stream.getVideoTracks()[0];
+					if (videoTrack) await context.deepsightService.checkVirtualCamera(videoTrack);
+				}
+			})();
+		},
+		cleanupDeepsight: ({ context }) => {
+			context.deepsightService?.cleanup();
 		}
 	},
 	guards: {
@@ -536,6 +557,7 @@ const _selfieMachine = setup({
 			return false;
 		},
 		hasStream: ({ context }) => context.stream !== void 0,
+		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && (context.config.deepsightLiveness !== "VIDEOLIVENESS" || context.deepsightService !== void 0),
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
 		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
 		hasUploadValidationError: ({ context }) => validateUploadResponse({
@@ -557,12 +579,14 @@ const _selfieMachine = setup({
 		capturedImage: void 0,
 		faceCoordinates: void 0,
 		uploadResponse: void 0,
+		processResponse: void 0,
 		recordingSession: void 0,
 		recordingStream: void 0,
 		attemptsRemaining: input.config.captureAttempts,
 		uploadError: void 0,
 		permissionResult: void 0,
-		resetDetection: void 0
+		resetDetection: void 0,
+		deepsightService: void 0
 	}),
 	on: { QUIT: { target: "#selfie.closed" } },
 	states: {
@@ -570,7 +594,7 @@ const _selfieMachine = setup({
 			target: "tutorial",
 			guard: "hasShowTutorial"
 		}, { target: "loading" }] } },
-		loading: { invoke: {
+		loading: { invoke: [{
 			id: "checkPermissionLoading",
 			src: "checkPermission",
 			onDone: [{
@@ -581,7 +605,13 @@ const _selfieMachine = setup({
 				target: "permissions",
 				actions: assign({ permissionResult: ({ event }) => event.output })
 			}]
-		} },
+		}, {
+			id: "loadingInitDeepsight",
+			src: "initializeDeepsightSession",
+			input: ({ context }) => ({ config: context.config }),
+			onDone: { actions: assign({ deepsightService: ({ event }) => event.output }) },
+			onError: { actions: () => void 0 }
+		}] },
 		tutorial: {
 			initial: "checkingPermission",
 			entry: "trackTutorialSelfie",
@@ -600,7 +630,7 @@ const _selfieMachine = setup({
 				} },
 				initializingCamera: {
 					initial: "booting",
-					invoke: {
+					invoke: [{
 						id: "tutorialInitCamera",
 						src: "initializeCamera",
 						input: ({ context }) => context.config,
@@ -613,12 +643,18 @@ const _selfieMachine = setup({
 							target: "ready",
 							actions: assign({ error: ({ event }) => String(event.error) })
 						}]
-					},
+					}, {
+						id: "tutorialInitDeepsight",
+						src: "initializeDeepsightSession",
+						input: ({ context }) => ({ config: context.config }),
+						onDone: { actions: assign({ deepsightService: ({ event }) => event.output }) },
+						onError: { actions: () => void 0 }
+					}],
 					states: {
 						booting: {
 							always: [{
 								target: "#tutorialCameraReady",
-								guard: "hasStream"
+								guard: "isCameraAndDeepsightReady"
 							}],
 							on: { NEXT_STEP: {
 								target: "waitingForStream",
@@ -627,7 +663,7 @@ const _selfieMachine = setup({
 						},
 						waitingForStream: { always: [{
 							target: "#selfie.capture",
-							guard: "hasStream"
+							guard: "isCameraAndDeepsightReady"
 						}] }
 					}
 				},
@@ -638,10 +674,29 @@ const _selfieMachine = setup({
 						actions: "trackContinue"
 					} }
 				},
-				ready: { on: { NEXT_STEP: {
-					target: "waitingForPermission",
-					actions: "trackContinue"
-				} } },
+				ready: {
+					initial: "idle",
+					states: {
+						idle: { always: [{
+							target: "initializingDeepsight",
+							guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS"
+						}, { target: "readyForNext" }] },
+						initializingDeepsight: { invoke: {
+							id: "initializeDeepsightTutorial",
+							src: "initializeDeepsightSession",
+							input: ({ context }) => ({ config: context.config }),
+							onDone: {
+								target: "readyForNext",
+								actions: assign({ deepsightService: ({ event }) => event.output })
+							},
+							onError: { target: "readyForNext" }
+						} },
+						readyForNext: { on: { NEXT_STEP: {
+							target: "#selfie.tutorial.waitingForPermission",
+							actions: "trackContinue"
+						} } }
+					}
+				},
 				waitingForPermission: { invoke: {
 					id: "checkPermissionWaiting",
 					src: "checkPermission",
@@ -657,8 +712,22 @@ const _selfieMachine = setup({
 			}
 		},
 		permissions: {
-			initial: "idle",
+			initial: "checkingDeepsight",
 			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS" && context.deepsightService === void 0
+				}, { target: "idle" }] },
+				initializingDeepsight: { invoke: {
+					id: "initializeDeepsightPerms",
+					src: "initializeDeepsightSession",
+					input: ({ context }) => ({ config: context.config }),
+					onDone: {
+						target: "idle",
+						actions: assign({ deepsightService: ({ event }) => event.output })
+					},
+					onError: { target: "idle" }
+				} },
 				idle: {
 					invoke: {
 						id: "checkPermissionIdle",
@@ -707,14 +776,29 @@ const _selfieMachine = setup({
 			}
 		},
 		capture: {
-			initial: "checkingStream",
+			initial: "checkingDeepsight",
 			exit: [
 				"stopMediaRecording",
 				"stopRecordingStream",
 				"clearRecordingSession",
-				"stopMediaStream"
+				"stopMediaStream",
+				"cleanupDeepsight"
 			],
 			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => context.config.deepsightLiveness === "VIDEOLIVENESS" && context.deepsightService === void 0
+				}, { target: "checkingStream" }] },
+				initializingDeepsight: { invoke: {
+					id: "initializeDeepsightCapture",
+					src: "initializeDeepsightSession",
+					input: ({ context }) => ({ config: context.config }),
+					onDone: {
+						target: "checkingStream",
+						actions: [assign({ deepsightService: ({ event }) => event.output })]
+					},
+					onError: { target: "checkingStream" }
+				} },
 				checkingStream: { always: [{
 					target: "detecting",
 					guard: "hasStream"
@@ -725,7 +809,7 @@ const _selfieMachine = setup({
 					input: ({ context }) => context.config,
 					onDone: {
 						target: "detecting",
-						actions: "setStreamAndCapturer"
+						actions: ["setStreamAndCapturer"]
 					},
 					onError: [{
 						target: "#selfie.permissions",
@@ -737,7 +821,12 @@ const _selfieMachine = setup({
 					}]
 				} },
 				detecting: {
-					entry: [assign({ detectionStatus: () => "detecting" }), "createRecordingStream"],
+					entry: [
+						assign({ detectionStatus: () => "detecting" }),
+						"createRecordingStream",
+						"checkVirtualCamera",
+						"startDeepsightRecording"
+					],
 					invoke: [{
 						id: "startRecording",
 						src: "startRecording",
@@ -807,7 +896,8 @@ const _selfieMachine = setup({
 						if (!canvas) throw new Error(FACE_ERROR_CODES.SERVER);
 						return {
 							canvas,
-							faceCoordinates: context.faceCoordinates
+							faceCoordinates: context.faceCoordinates,
+							deepsightService: context.deepsightService
 						};
 					},
 					onDone: {
@@ -834,10 +924,19 @@ const _selfieMachine = setup({
 				} } },
 				success: {
 					entry: "stopMediaRecording",
-					after: { 3e3: { target: "#selfie.finished" } }
+					after: { 3e3: { target: "#selfie.processing" } }
 				}
 			}
 		},
+		processing: { invoke: {
+			id: "processFace",
+			src: "processFace",
+			onDone: {
+				target: "finished",
+				actions: assign({ processResponse: ({ event }) => event.output })
+			},
+			onError: { target: "finished" }
+		} },
 		finished: {
 			entry: "stopMediaStream",
 			on: { RESET: {
@@ -916,7 +1015,11 @@ function mapState(snapshot) {
 		attemptsRemaining: context.attemptsRemaining,
 		uploadError: context.uploadError
 	};
-	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		processResponse: context.processResponse
+	};
 	if (snapshot.matches("error")) return {
 		status: "error",
 		error: context.error ?? "Unknown error"
@@ -992,4 +1095,4 @@ function createSelfieManager(options) {
 }
 
 //#endregion
-export { createSelfieManager, selfieMachine };
+export { createSelfieManager, processFace, selfieMachine };

package/dist/{permissionServices-I6vX6DBy.esm.js → streamingEvents-B3hNanPl.esm.js}

@@ -1,12 +1,6 @@
-import { h as stopCameraStream, m as requestCameraAccess, p as queryCameraPermission } from "./endpoints-BSTFaHYo.esm.js";
+import { T as stopCameraStream, b as queryCameraPermission, w as requestCameraAccess } from "./endpoints-D9TGnxRK.esm.js";
+import { a as getUserAgent } from "./recordingsRepository-D5MURoVB.esm.js";
 
-//#region ../infra/src/device/getBrowser.ts
-function getUserAgent() {
-	if (typeof navigator === "undefined") return "";
-	return navigator.userAgent;
-}
-
-//#endregion
 //#region ../infra/src/device/getDeviceClass.ts
 function getDeviceInfo() {
 	if (typeof navigator === "undefined") return {
@@ -20,6 +14,24 @@ function getDeviceInfo() {
 		maxTouchPoints: navigator.maxTouchPoints
 	};
 }
+/**
+* Gets the current window dimensions.
+* Returns default values (1280x720) in non-browser environments.
+*/
+function getWindowDimensions(defaultWidth = 1280, defaultHeight = 720) {
+	if (typeof window === "undefined") return {
+		outerWidth: defaultWidth,
+		outerHeight: defaultHeight,
+		innerWidth: defaultWidth,
+		innerHeight: defaultHeight
+	};
+	return {
+		outerWidth: window.outerWidth,
+		outerHeight: window.outerHeight,
+		innerWidth: window.innerWidth,
+		innerHeight: window.innerHeight
+	};
+}
 
 //#endregion
 //#region src/internal/device/getBrowser.ts
@@ -69,4 +81,17 @@ async function requestPermission() {
 }
 
 //#endregion
-export { getBrowser as i, requestPermission as n, getDeviceClass as r, checkPermission as t };
+//#region src/internal/recordings/streamingEvents.ts
+const streamingEvents = {
+	strSessionDidConnect: "strSessionDidConnect",
+	strSessionDidDisconnect: "strSessionDidDisconnect",
+	strSessionDidFailWithError: "strSessionDidFailWithError",
+	strStreamVideoCaptureStart: "strStreamVideoCaptureStart",
+	strStreamVideoCaptureStop: "strStreamVideoCaptureStop",
+	strStreamPublisherCreated: "strStreamPublisherCreated",
+	strStreamPublisherDestroyed: "strStreamPublisherDestroyed",
+	strStreamPublisherDidFailWithError: "strStreamPublisherDidFailWithError"
+};
+
+//#endregion
+export { getBrowser as a, getDeviceClass as i, checkPermission as n, getWindowDimensions as o, requestPermission as r, streamingEvents as t };