@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/deepsightService-O74l4Y__.esm.js

@@ -0,0 +1,489 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as isBrowserSimulation } from "./browserSimulation-gxD8cSpM.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-PA2Ljri3.esm.js";
+import { n as getDeviceInfo, t as getUserAgent } from "./getBrowser-BSXUTWXw.esm.js";
+import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
+
+//#region ../infra/src/media/canvas.ts
+/**
+* Class representing a canvas element for image capture and manipulation.
+*/
+var IncodeCanvas = class IncodeCanvas {
+	/**
+	* Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+	* @param imageData - Frame pixels in RGBA format
+	* @returns An {@link IncodeCanvas} containing the provided pixels
+	*/
+	static fromImageData(imageData) {
+		const canvas = document.createElement("canvas");
+		canvas.width = imageData.width;
+		canvas.height = imageData.height;
+		const context = canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return new IncodeCanvas(canvas);
+		if ("putImageData" in context) context.putImageData(imageData, 0, 0);
+		return new IncodeCanvas(canvas);
+	}
+	/**
+	* Create a new canvas element.
+	* @param canvas_ - The canvas element to clone.
+	*/
+	constructor(canvas_) {
+		this.base64Image = null;
+		this.blobData = null;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = canvas_.width;
+		this.canvas.height = canvas_.height;
+		const context = this.canvas.getContext("2d");
+		if (context) context.drawImage(canvas_, 0, 0);
+	}
+	/**
+	* Check if the current canvas is valid.
+	*/
+	checkCanvas() {
+		return this.canvas && this.canvas.width > 1 && this.canvas.height > 1;
+	}
+	/**
+	* Disposes of resources, including revoking object URLs to prevent memory leaks.
+	*/
+	dispose() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = null;
+		}
+		this.base64Image = null;
+	}
+	/**
+	* Release the data stored by IncodeCanvas.
+	*/
+	release() {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = 1;
+		this.canvas.height = 1;
+		this.canvas.getContext("2d")?.clearRect(0, 0, 1, 1);
+		this.base64Image = null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		this.blobData = null;
+	}
+	/**
+	* Revokes the object URL if one exists, preventing memory leaks.
+	* Use this when you no longer need the preview image URL.
+	*/
+	revokeObjectURL() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = {
+				...this.blobData,
+				url: ""
+			};
+		}
+	}
+	/**
+	* Get the width of the canvas.
+	*/
+	width() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.width;
+	}
+	/**
+	* Get the height of the canvas.
+	*/
+	height() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.height;
+	}
+	/**
+	* Set the width of the canvas.
+	*/
+	setWidth(width) {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = width;
+	}
+	/**
+	* Set the height of the canvas.
+	*/
+	setHeight(height) {
+		if (!this.checkCanvas()) return;
+		this.canvas.height = height;
+	}
+	/**
+	* Clone the current canvas.
+	*/
+	clone() {
+		if (!this.checkCanvas()) return null;
+		const cloned = new IncodeCanvas(this.canvas);
+		cloned.setBase64Image(this.base64Image);
+		return cloned;
+	}
+	/**
+	* Deep clone the current IncodeCanvas including blob data.
+	*/
+	async deepClone() {
+		const cloned = this.clone();
+		if (!cloned) return null;
+		if (this.blobData) await cloned.setBlobData(this.blobData);
+		return cloned;
+	}
+	/**
+	* Returns the drawing context on the canvas.
+	*/
+	getContext(contextId, contextAttributes) {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext(contextId, contextAttributes);
+		return context instanceof CanvasRenderingContext2D ? context : null;
+	}
+	/**
+	* Retrieves the image data from the canvas.
+	*/
+	getImageData() {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return null;
+		return context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+	}
+	/**
+	* Updates the base64 representation of the current canvas image.
+	*/
+	updateBase64Image(jpegQuality = 1) {
+		if (!this.checkCanvas()) return;
+		this.base64Image = this.canvas.toDataURL("image/jpeg", jpegQuality);
+	}
+	/**
+	* Converts the current canvas element to a base64 string.
+	*/
+	getBase64Image(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64Image = this.base64Image;
+		if (base64Image === null) return null;
+		if (includeDataURLPrefix) return base64Image;
+		const commaIndex = base64Image.indexOf(",");
+		if (commaIndex === -1) return base64Image;
+		return base64Image.slice(commaIndex + 1);
+	}
+	/**
+	* Sets the base64 representation of the current canvas image.
+	*/
+	setBase64Image(base64Image) {
+		this.base64Image = base64Image;
+	}
+	/**
+	* Updates the Blob representation of the current canvas image.
+	*/
+	updateBlob(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64 = this.getBase64Image(jpegQuality, includeDataURLPrefix);
+		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
+	}
+	/**
+	* Converts a base64 string to a Blob and creates a URL for it.
+	*/
+	static base64ToBlob(base64) {
+		try {
+			const binary = atob(base64);
+			const array = [];
+			for (let i = 0; i < binary.length; i++) array.push(binary.charCodeAt(i));
+			const blob = new Blob([new Uint8Array(array)]);
+			return {
+				blob,
+				url: URL.createObjectURL(blob)
+			};
+		} catch (error) {
+			console.error("Failed to convert base64 string to Blob:", error);
+		}
+		return null;
+	}
+	/**
+	* Retrieves the Blob data and its URL from the current canvas.
+	*/
+	getBlobData(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.blobData === null) this.updateBlob(jpegQuality, includeDataURLPrefix);
+		return this.blobData;
+	}
+	/**
+	* Sets the Blob data of the current canvas image.
+	*/
+	async setBlobData(blobData) {
+		const blobDataArrayBuffer = await blobData.blob.arrayBuffer();
+		this.blobData = {
+			blob: new Blob([blobDataArrayBuffer], { type: blobData.blob.type }),
+			url: blobData.url
+		};
+	}
+	/**
+	* Returns a resized canvas according to video element size.
+	*/
+	getResizedCanvas(videoElementWidth, videoElementHeight) {
+		if (!this.checkCanvas()) return null;
+		const cameraOffsetX = Math.abs(videoElementWidth - window.innerWidth);
+		const resized = new IncodeCanvas(document.createElement("canvas"));
+		const canvasHeight = this.height();
+		if (!canvasHeight) return null;
+		const ratio = canvasHeight / videoElementHeight;
+		const newWidth = window.innerWidth;
+		const newHeight = window.innerHeight;
+		resized.setWidth(newWidth);
+		resized.setHeight(newHeight);
+		const context = resized.getContext("2d");
+		if (!context) return null;
+		context.drawImage(this.canvas, ratio * cameraOffsetX / 2, 0, ratio * newWidth, ratio * newHeight, 0, 0, newWidth, newHeight);
+		return resized;
+	}
+};
+
+//#endregion
+//#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: () => {
+			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 isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const deviceInfo = getDeviceInfo();
+			const visitorId = browserEnv.generateCanvasFingerprint();
+			const ip = disableIpify ? "" : await ipLookup.getIp();
+			const screenDimensions = browserEnv.getScreenDimensions();
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model: "",
+				os: void 0,
+				osVersion: void 0,
+				screenDimensions,
+				numTouchPoints: deviceInfo.maxTouchPoints,
+				fingerprintHash: visitorId,
+				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();
+		},
+		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 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 { IncodeCanvas as n, createDeepsightService as t };

package/dist/device.d.ts

@@ -0,0 +1,46 @@
+//#region ../infra/src/capabilities/platform.d.ts
+
+declare function isIPad(userAgent?: string): boolean;
+//#endregion
+//#region ../infra/src/capabilities/IScreenOrientationCapability.d.ts
+type ScreenOrientationState = 'portrait' | 'landscape';
+type IScreenOrientationCapability = {
+  readonly current: ScreenOrientationState;
+  subscribe(callback: (state: ScreenOrientationState) => void): () => void;
+  cleanup(): void;
+};
+//#endregion
+//#region ../infra/src/providers/browser/ScreenOrientationProvider.d.ts
+declare class ScreenOrientationProvider implements IScreenOrientationCapability {
+  private _current;
+  private subscribers;
+  private orientationChangeHandler;
+  private resizeHandler;
+  private mediaQueryList;
+  private mediaQueryHandler;
+  constructor();
+  get current(): ScreenOrientationState;
+  subscribe(callback: (state: ScreenOrientationState) => void): () => void;
+  cleanup(): void;
+  private handleOrientationChange;
+  private handleResize;
+  private updateState;
+}
+//#endregion
+//#region src/internal/device/getBrowser.d.ts
+type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera' | 'other' | 'samsung_browser';
+declare function getBrowser(): Browser;
+//#endregion
+//#region src/internal/device/getDeviceClass.d.ts
+type DeviceClass = 'ios' | 'android' | 'desktop';
+declare function getDeviceClass(): DeviceClass;
+//#endregion
+//#region src/internal/device/screenOrientation.d.ts
+type ScreenOrientationObserver = {
+  get isLandscapeMobile(): boolean;
+  subscribe(callback: (isLandscapeMobile: boolean) => void): () => void;
+  cleanup(): void;
+};
+declare function createScreenOrientationObserver(provider: IScreenOrientationCapability, deviceClass: DeviceClass): ScreenOrientationObserver;
+//#endregion
+export { type Browser, type DeviceClass, type ScreenOrientationObserver, ScreenOrientationProvider, createScreenOrientationObserver, getBrowser, getDeviceClass, isIPad };

package/dist/device.esm.js

@@ -0,0 +1,106 @@
+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";
+
+//#region src/internal/device/getBrowser.ts
+function getBrowser() {
+	const userAgent = getUserAgent();
+	if (!userAgent) return "other";
+	const ua = userAgent.toLowerCase();
+	if (ua.includes("edg/") || ua.includes("edgios/")) return "edge";
+	if (ua.includes("samsungbrowser/")) return "samsung_browser";
+	if (ua.includes("opr/") || ua.includes("opera") || ua.includes("opios/") || ua.includes("opt/")) return "opera";
+	if (ua.includes("chrome") || ua.includes("crios")) return "chrome";
+	if (ua.includes("firefox") || ua.includes("fxios")) return "firefox";
+	if (ua.includes("safari")) return "safari";
+	return "other";
+}
+
+//#endregion
+//#region src/internal/device/screenOrientation.ts
+function createScreenOrientationObserver(provider, deviceClass) {
+	const getIsLandscapeMobile = () => deviceClass !== "desktop" && !isIPad() && provider.current === "landscape";
+	return {
+		get isLandscapeMobile() {
+			return getIsLandscapeMobile();
+		},
+		subscribe(callback) {
+			return provider.subscribe(() => {
+				callback(getIsLandscapeMobile());
+			});
+		},
+		cleanup: () => provider.cleanup()
+	};
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/ScreenOrientationProvider.ts
+function isPortrait() {
+	if (typeof window === "undefined" || typeof screen === "undefined") return true;
+	if (typeof window.matchMedia === "function") return !window.matchMedia("(orientation: landscape)").matches;
+	if (screen.orientation?.type?.includes("portrait")) return true;
+	if (screen.orientation?.type?.includes("landscape")) return false;
+	const orientation = window.orientation;
+	if (typeof orientation === "number") return Math.abs(orientation) === 0;
+	return window.innerHeight >= window.innerWidth;
+}
+function toState(portrait) {
+	return portrait ? "portrait" : "landscape";
+}
+var ScreenOrientationProvider = class {
+	constructor() {
+		this._current = toState(isPortrait());
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.orientationChangeHandler = this.handleOrientationChange.bind(this);
+		this.resizeHandler = this.handleResize.bind(this);
+		this.mediaQueryList = null;
+		this.mediaQueryHandler = this.handleResize.bind(this);
+		if (typeof window === "undefined") return;
+		if (screen.orientation) screen.orientation.addEventListener("change", this.orientationChangeHandler);
+		else window.addEventListener("orientationchange", this.orientationChangeHandler);
+		window.addEventListener("resize", this.resizeHandler);
+		if (typeof window.matchMedia === "function") {
+			this.mediaQueryList = window.matchMedia("(orientation: landscape)");
+			this.mediaQueryList.addEventListener("change", this.mediaQueryHandler);
+		}
+	}
+	get current() {
+		return this._current;
+	}
+	subscribe(callback) {
+		this.subscribers.add(callback);
+		callback(this._current);
+		return () => {
+			this.subscribers.delete(callback);
+		};
+	}
+	cleanup() {
+		if (typeof window === "undefined") return;
+		if (screen.orientation) screen.orientation.removeEventListener("change", this.orientationChangeHandler);
+		else window.removeEventListener("orientationchange", this.orientationChangeHandler);
+		window.removeEventListener("resize", this.resizeHandler);
+		this.mediaQueryList?.removeEventListener("change", this.mediaQueryHandler);
+		this.mediaQueryList = null;
+		this.subscribers.clear();
+	}
+	handleOrientationChange() {
+		setTimeout(() => {
+			this.updateState();
+			if (document.activeElement instanceof HTMLElement) document.activeElement.blur();
+			window.focus();
+		}, 0);
+	}
+	handleResize() {
+		this.updateState();
+	}
+	updateState() {
+		const next = toState(isPortrait());
+		if (next !== this._current) {
+			this._current = next;
+			for (const cb of this.subscribers) cb(this._current);
+		}
+	}
+};
+
+//#endregion
+export { ScreenOrientationProvider, createScreenOrientationObserver, getBrowser, getDeviceClass, isIPad };

package/dist/displayErrors-DqJ_IbsG.d.ts

@@ -0,0 +1,39 @@
+//#region src/shared/types.d.ts
+/** A single form field definition for dynamic rendering. */
+type FieldDef = {
+  name: string;
+  type: 'text' | 'tel' | 'date' | 'dropdown' | 'phone' | 'radio';
+  label: string;
+  displayLabel?: string;
+  placeholder?: string;
+  placeholderParams?: Record<string, string>;
+  required: boolean;
+  optional?: boolean;
+  maxLength?: number;
+  options?: {
+    value: string;
+    label: string;
+  }[];
+  readonly?: boolean;
+  section?: string;
+  disableCountrySelector?: boolean;
+};
+/** An address suggestion returned by the address autocomplete API. */
+type AddressSuggestion = {
+  id: string | number;
+  label: string;
+  street?: string;
+  city?: string;
+  stateCode?: string;
+  postalCode?: string;
+  houseNumber?: string;
+  countryCode?: string;
+};
+//#endregion
+//#region src/shared/displayErrors.d.ts
+type DisplayErrorsResult = {
+  displayErrors: Record<string, string>;
+  errorParams: Record<string, Record<string, string | number>>;
+};
+//#endregion
+export { AddressSuggestion as n, FieldDef as r, DisplayErrorsResult as t };