@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/recordingsRepository-CTjaf-ER.esm.js

@@ -0,0 +1,256 @@
+import { n as api, t as endpoints } from "./endpoints-B0ltwtb5.esm.js";
+import { t as getUserAgent } from "./getBrowser-CLEzz0Hi.esm.js";
+
+//#region src/internal/deepsight/metadataService.ts
+function getWebGLFingerprint() {
+	try {
+		const canvas = document.createElement("canvas");
+		const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+		if (!gl) return "";
+		const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+		if (!debugInfo) return "";
+		return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+	} catch {
+		return "";
+	}
+}
+function isBrowserSimulation() {
+	const win = window;
+	const nav = navigator;
+	return !!(win.callPhantom || win._phantom || win.phantom || win.__nightmare || nav.webdriver || win.domAutomation || win.domAutomationController);
+}
+async function getFingerPrint(disableIpify = false) {
+	let visitorId = "";
+	let ip = "";
+	try {
+		const canvas = document.createElement("canvas");
+		const ctx = canvas.getContext("2d");
+		if (ctx) {
+			ctx.textBaseline = "top";
+			ctx.font = "14px Arial";
+			ctx.fillText("fingerprint", 2, 2);
+			visitorId = canvas.toDataURL().slice(-50);
+		}
+	} catch {}
+	if (!disableIpify) try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), 3e3);
+		const response = await fetch("https://api.ipify.org?format=json", { signal: controller.signal });
+		clearTimeout(timeoutId);
+		ip = (await response.json()).ip || "";
+	} catch {}
+	return {
+		visitorId,
+		ip
+	};
+}
+function createMetadataService(wasmUtil, visibility) {
+	return {
+		async initialize(sdkVersion, disableIpify = false) {
+			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkVersion(sdkVersion);
+			const ua = getUserAgent();
+			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const fingerPrint = await getFingerPrint(disableIpify).catch(() => ({
+				visitorId: "",
+				ip: ""
+			}));
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model: "",
+				os: void 0,
+				osVersion: void 0,
+				screenDimensions: {
+					width: screen.width,
+					height: screen.height
+				},
+				numTouchPoints: navigator.maxTouchPoints,
+				fingerprintHash: fingerPrint.visitorId || "",
+				ip: fingerPrint.ip || "",
+				backgroundMode: false
+			};
+			wasmUtil.setDeviceInfo(deviceMetadata);
+			const nav = navigator;
+			const browserInfo = {
+				userAgent: ua,
+				getUserMediaAvailability: {
+					webkit: nav.webkitGetUserMedia !== void 0,
+					moz: nav.mozGetUserMedia !== void 0,
+					o: nav.oGetUserMedia !== void 0,
+					ms: nav.msGetUserMedia !== void 0
+				},
+				webglFingerprint: getWebGLFingerprint(),
+				inspectorOpened: false,
+				isMockedBrowser: isBrowserSimulation()
+			};
+			wasmUtil.setBrowserInfo(browserInfo, false);
+		},
+		updateCameraInfo(videoTrack) {
+			const settings = videoTrack.getSettings();
+			const capabilities = videoTrack.getCapabilities?.() ?? {};
+			const labels = videoTrack.label ? [videoTrack.label] : [];
+			const cameraInfo = {
+				facingMode: settings.facingMode === "user" ? "frontal" : settings.facingMode === "environment" ? "back" : settings.facingMode || "unknown",
+				settings,
+				capabilities,
+				labels
+			};
+			wasmUtil.setCameraInfo(cameraInfo);
+		},
+		async checkForVirtualCameraByLabel(videoTrack = null) {
+			try {
+				if (!videoTrack) {
+					const devices = await navigator.mediaDevices.enumerateDevices();
+					for (const device of devices) if (device.kind === "videoinput" && wasmUtil.isVirtualCamera(device.label)) return true;
+				}
+				if (videoTrack && wasmUtil.isVirtualCamera(videoTrack.label)) return true;
+				return false;
+			} catch {
+				return false;
+			}
+		},
+		async analyzeFrame(imageData) {
+			await wasmUtil.analyzeFrame(imageData);
+		},
+		setMotionStatus(status) {
+			wasmUtil.setMotionStatus(status);
+		},
+		setBackgroundMode(backgroundMode) {
+			wasmUtil.setBackgroundMode(backgroundMode || visibility.wasBackgrounded);
+			visibility.reset();
+		},
+		estimatePerformance() {
+			return wasmUtil.estimatePerformance();
+		},
+		getMetadata() {
+			return wasmUtil.getMetadata();
+		},
+		getCheck() {
+			return wasmUtil.getCheck();
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/motionStatusService.ts
+function createMotionStatusService(motionSensor) {
+	return {
+		async requestPermission() {
+			return motionSensor.requestPermission();
+		},
+		async start() {
+			await motionSensor.start();
+		},
+		stop() {
+			motionSensor.stop();
+		},
+		check() {
+			return motionSensor.check();
+		},
+		get isRunning() {
+			return motionSensor.isRunning;
+		},
+		get hasPermission() {
+			return motionSensor.hasPermission;
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/deepsightService.ts
+function createDeepsightService(config) {
+	const metadata = createMetadataService(config.wasmUtil, config.visibility);
+	const motion = createMotionStatusService(config.motionSensor);
+	return {
+		metadata,
+		motion,
+		recorder: config.recorder,
+		async initialize(disableIpify = false) {
+			await metadata.initialize(config.sdkVersion, disableIpify);
+			metadata.estimatePerformance();
+		},
+		async requestMotionPermission() {
+			return motion.requestPermission();
+		},
+		async startMotionSensors() {
+			await motion.start();
+		},
+		stopMotionSensors() {
+			motion.stop();
+		},
+		startRecording(stream) {
+			config.recorder.startRecording(stream);
+		},
+		async checkVirtualCamera(videoTrack) {
+			metadata.updateCameraInfo(videoTrack);
+			return metadata.checkForVirtualCameraByLabel(videoTrack);
+		},
+		async performVirtualCameraCheck() {
+			const output = {
+				canvas: null,
+				itr: null,
+				skipped: null
+			};
+			await config.wasmUtil.poc(output);
+			if (output?.skipped === false) config.wasmUtil.setZc(output?.itr === true ? "FAIL" : "PASS");
+		},
+		async performCapture(sessionToken, imageData) {
+			let recordingId = null;
+			if (config.recorder.isRecording) {
+				const result = await config.recorder.stopRecording(10, (base64) => config.wasmUtil.encryptImage(base64), (buffer) => config.wasmUtil.ckvcks(buffer));
+				try {
+					recordingId = await config.uploadVideo(result.encryptedVideo, sessionToken);
+				} catch (error) {
+					console.error("[DeepsightService] Failed to upload video:", error);
+				}
+			}
+			await this.performVirtualCameraCheck();
+			await metadata.analyzeFrame(imageData);
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+			return {
+				metadata: metadata.getMetadata(),
+				recordingId
+			};
+		},
+		cleanup() {
+			motion.stop();
+			config.recorder.reset();
+		}
+	};
+}
+
+//#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(videoRecordingId) {
+	return (await api.post(endpoints.recordingStopV2, { videoRecordingId })).data;
+}
+async function uploadDeepsightVideo(encryptedVideo, token) {
+	try {
+		return (await api.post(endpoints.deepsightVideoImport, {
+			video: encryptedVideo,
+			type: "selfie"
+		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
+	} catch (error) {
+		console.error("Error uploading deepsight video:", error);
+		return "";
+	}
+}
+
+//#endregion
+export { createDeepsightService as a, uploadDeepsightVideo as i, startRecording as n, stopRecording as r, createRecordingSession as t };