@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/deepsightService-CrHmvx8X.esm.js

@@ -0,0 +1,276 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
+import { n as getThumbmarkId, r as getParsedUserAgent, t as isBrowserSimulation } from "./browserSimulation-B1dWiXp7.esm.js";
+import { t as getUserAgent } from "./getBrowser-C8DP7oTB.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DJWm3V4g.esm.js";
+import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
+import { t as getDeviceInfo } from "./getDeviceClass-C0olyNFS.esm.js";
+
+//#region ../infra/src/media/video.ts
+/**
+* Creates a hidden video element for a stream and appends it to document.body.
+*/
+function createHiddenVideoElement(stream) {
+	if (typeof document === "undefined") throw new Error("Document not available");
+	const video = document.createElement("video");
+	video.autoplay = true;
+	video.playsInline = true;
+	video.muted = true;
+	video.srcObject = stream;
+	video.style.width = "0px";
+	video.style.height = "0px";
+	video.style.position = "absolute";
+	video.style.top = "0";
+	video.style.left = "0";
+	video.style.zIndex = "-1";
+	document.body.appendChild(video);
+	return {
+		element: video,
+		dispose: () => {
+			const current = video.srcObject;
+			if (current instanceof MediaStream) for (const track of current.getTracks()) track.stop();
+			video.srcObject = null;
+			if (video.parentElement) video.parentElement.removeChild(video);
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/metadataService.ts
+function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
+	return {
+		async initialize(sdkVersion, disableIpify = false) {
+			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkVersion(sdkVersion);
+			const ua = getUserAgent();
+			const parsedUa = getParsedUserAgent(ua);
+			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const deviceInfo = getDeviceInfo();
+			let fingerprintHash = "";
+			try {
+				fingerprintHash = await getThumbmarkId();
+			} catch {
+				fingerprintHash = browserEnv.generateCanvasFingerprint();
+			}
+			const ip = disableIpify ? "" : await ipLookup.getIp();
+			const screenDimensions = browserEnv.getScreenDimensions();
+			const model = [parsedUa.device.vendor, parsedUa.device.model].filter(Boolean).join(" ");
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model,
+				os: parsedUa.os.name ?? "",
+				osVersion: parsedUa.os.version ?? "",
+				screenDimensions,
+				numTouchPoints: deviceInfo.maxTouchPoints,
+				fingerprintHash,
+				ip,
+				backgroundMode: false
+			};
+			wasmUtil.setDeviceInfo(deviceMetadata);
+			const navigatorPrefixes = browserEnv.getNavigatorPrefixes();
+			const browserInfo = {
+				userAgent: ua,
+				getUserMediaAvailability: {
+					webkit: navigatorPrefixes.webkit,
+					moz: navigatorPrefixes.moz,
+					o: navigatorPrefixes.o,
+					ms: navigatorPrefixes.ms
+				},
+				webglFingerprint: browserEnv.getWebGLRenderer(),
+				inspectorOpened: false,
+				isMockedBrowser: isBrowserSimulation(browserEnv)
+			};
+			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 labels = await browserEnv.enumerateVideoDeviceLabels();
+					for (const label of labels) if (wasmUtil.isVirtualCamera(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();
+		},
+		getPipelineState() {
+			return wasmUtil.getPipelineState();
+		},
+		preparePipelineState() {
+			wasmUtil.getPipelineState();
+		}
+	};
+}
+
+//#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/virtualCameraCheck.ts
+/**
+* Sends the analyzed frame image to the backend for logging.
+*/
+async function logFrame({ source, base64Image, token }) {
+	try {
+		return (await api.post("/omni/log/frame/v2", { base64Image }, {
+			query: { source },
+			headers: { "X-Incode-Hardware-Id": token }
+		})).data;
+	} catch {
+		return;
+	}
+}
+/**
+* Runs the WASM virtual camera check and handles logging and stats.
+*/
+async function runVirtualCameraCheck({ wasmUtil, source, token }) {
+	const output = {
+		canvas: null,
+		itr: null,
+		skipped: null
+	};
+	await wasmUtil.poc(output);
+	if (output.skipped !== false) return;
+	if (output.canvas && token) {
+		const base64Image = new IncodeCanvas(output.canvas).getBase64Image();
+		if (base64Image) await logFrame({
+			source,
+			base64Image,
+			token
+		});
+	}
+	if (output.itr === true) {
+		addDeviceStats({ virtualCameraDetected: true });
+		wasmUtil.setZc("FAIL");
+	} else if (output.itr === false) wasmUtil.setZc("PASS");
+}
+
+//#endregion
+//#region src/internal/deepsight/deepsightService.ts
+function createDeepsightService(config) {
+	const metadata = createMetadataService(config.wasmUtil, config.visibility, config.browserEnv, config.ipLookup);
+	const motion = createMotionStatusService(config.motionSensor);
+	return {
+		metadata,
+		motion,
+		async initialize(disableIpify = false) {
+			await metadata.initialize(config.sdkVersion, disableIpify);
+			metadata.estimatePerformance();
+		},
+		async requestMotionPermission() {
+			return motion.requestPermission();
+		},
+		async startMotionSensors() {
+			await motion.start();
+		},
+		async primeWasmMotionSensor() {
+			await config.wasmUtil.rsp();
+			config.wasmUtil.ssl();
+		},
+		stopMotionSensors() {
+			motion.stop();
+		},
+		async checkVirtualCamera(videoTrack) {
+			metadata.updateCameraInfo(videoTrack);
+			return metadata.checkForVirtualCameraByLabel(videoTrack);
+		},
+		async performVirtualCameraCheck(sessionToken, source) {
+			await runVirtualCameraCheck({
+				wasmUtil: config.wasmUtil,
+				source,
+				token: sessionToken
+			});
+		},
+		async performPrcCheck(params) {
+			const prcStream = await requestCameraAccess(params.constraints);
+			const hiddenVideo = createHiddenVideoElement(prcStream);
+			try {
+				await config.wasmUtil.prc();
+			} finally {
+				hiddenVideo.dispose();
+				stopCameraStream(prcStream);
+			}
+		},
+		async analyzeFrame(imageData) {
+			await motion.start();
+			await metadata.analyzeFrame(imageData);
+			metadata.preparePipelineState();
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+		},
+		getMetadata() {
+			return metadata.getMetadata();
+		},
+		getMotionStatus() {
+			return motion.check();
+		},
+		getAnalysisStatus() {
+			return metadata.getCheck();
+		},
+		getPipelineState() {
+			return metadata.getPipelineState();
+		},
+		cleanup() {
+			motion.stop();
+		}
+	};
+}
+
+//#endregion
+export { createDeepsightService as t };

package/dist/device.esm.js

@@ -1,6 +1,7 @@
-import { i as isIPad } from "./platform-CfrjKhmi.esm.js";
-import { t as getUserAgent } from "./getBrowser-BSXUTWXw.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+import { i as isIPad } from "./platform-SKvEfCBh.esm.js";
+import { t as getUserAgent } from "./getBrowser-C8DP7oTB.esm.js";
+import "./getDeviceClass-C0olyNFS.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-C8Do2qYu.esm.js";
 
 //#region src/internal/device/getBrowser.ts
 function getBrowser() {