@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/idCaptureServices-CFDwqTtQ.esm.js

@@ -0,0 +1,396 @@
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-DS_Nj5Gg.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as isDesktop } from "./platform-BJrm5nzZ.esm.js";
+import { h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-f81FVdQs.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-9y-kbVDw.esm.js";
+import { n as preloadOpenViduProvider } from "./recordingService-CFpfdXSS.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-WeHbQM7W.esm.js";
+//#region src/modules/id/idCameraStream.ts
+async function getIdCameraStream(deviceId) {
+	return getBackCameraStream(deviceId);
+}
+//#endregion
+//#region src/modules/id/idCaptureExperiments.ts
+/**
+* IDC-05 — resolved by core because `framesAggregationInterval` feeds
+* `setThresholds` before detection can run.
+*/
+const CAPTURE_RESULT_PREVIEW = {
+	storeParam: "captureResultPreview",
+	...defineExperimentParams({
+		showCaptureResultPreview: booleanParam(false),
+		framesAggregationInterval: numberParam(DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval)
+	})
+};
+//#endregion
+//#region src/modules/id/idCaptureThresholds.ts
+function resolveCaptureResultPreviewTreatment(config) {
+	if (config.supportsCaptureResultPreview !== true) return void 0;
+	const { params } = resolveExperimentOnce(CAPTURE_RESULT_PREVIEW);
+	return {
+		mode: params.showCaptureResultPreview ? "result-preview" : "countdown",
+		framesAggregationInterval: params.framesAggregationInterval
+	};
+}
+/**
+* Single source of truth for the WASM ID-capture thresholds passed to
+* `IIdCaptureCapability.setThresholds`. Resolves `framesAggregationInterval`
+* — the countdown / best-frame aggregation window (canonical default
+* 3000ms) — with precedence:
+*
+* 1. An explicit `config.thresholds.framesAggregationInterval` (host/headless
+*    override) always wins — including when allocated to the treatment arm,
+*    which then runs the treatment UI on the host's aggregation window.
+* 2. Otherwise, the IDC-05 experiment's `framesAggregationInterval`.
+* 3. Otherwise, the canonical default.
+*
+* `idDetectedTimeout`/`autocaptureTimeout` are derived here too (from
+* `deviceIdleTimeout`/`autoCaptureTimeout`, seconds -> ms), same as before —
+* centralizing the whole threshold shape avoids the two former call sites
+* (`initializeIdCapture`, `runDetectionActor`) each rebuilding it slightly
+* differently.
+*
+* Call this once per capture session, at actor creation
+* (`createIdCaptureActor` / `createIdCaptureOnlyActor`), and store the
+* result back onto `config.thresholds` — so the parameter store is read at
+* most once per session and every downstream consumer sees the same
+* fully-resolved thresholds instead of re-deriving them.
+*/
+function resolveIdCaptureThresholds(config, experimentInterval) {
+	return {
+		...DEFAULT_ID_CAPTURE_THRESHOLDS,
+		...config.thresholds,
+		framesAggregationInterval: config.thresholds?.framesAggregationInterval ?? experimentInterval ?? DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval,
+		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? (config.deviceIdleTimeout ?? 10) * 1e3,
+		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? (config.autoCaptureTimeout ?? 5) * 1e3
+	};
+}
+//#endregion
+//#region src/modules/id/types.ts
+const ID_ERROR_CODES = {
+	UPLOAD_ERROR: "UPLOAD_ERROR",
+	CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED",
+	LOW_SHARPNESS: "LOW_SHARPNESS",
+	GLARE_DETECTED: "GLARE_DETECTED",
+	WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE",
+	ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE",
+	READABILITY_ISSUE: "READABILITY_ISSUE",
+	RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK",
+	RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK",
+	NO_MORE_TRIES: "NO_MORE_TRIES",
+	UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
+	NO_TOKEN: "NO_TOKEN",
+	PERMISSION_DENIED: "PERMISSION_DENIED",
+	USER_CANCELLED: "USER_CANCELLED",
+	SERVER: "SERVER_ERROR"
+};
+//#endregion
+//#region src/modules/id/idCaptureServices.ts
+/**
+* Camera constraints used for PRC warmup before ID capture.
+* Uses environment-facing camera on mobile devices (for back camera ID capture)
+* and user-facing camera on desktop.
+*/
+function getPrcCameraConstraints() {
+	if (isDesktop()) return { video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	} };
+	return { video: {
+		facingMode: "environment",
+		height: { ideal: 720 }
+	} };
+}
+function getUploadEndpoint(type, isSecondId) {
+	if (isSecondId) return type === "front" ? endpoints.frontSecondId : endpoints.backSecondId;
+	return type === "front" ? endpoints.frontId : endpoints.backId;
+}
+const SHARPNESS_THRESHOLD = 10;
+const GLARE_THRESHOLD = 10;
+const DEFAULT_ID_CAPTURE_SETTINGS = {
+	isFixedMask: false,
+	isIPhone14OrHigher: false,
+	idType: "",
+	blurCheckEnabled: false,
+	glareCheckEnabled: false,
+	faceQualityCheckEnabled: true,
+	iouCheckEnabled: true,
+	fpsLimitEnabled: false
+};
+async function initializeIdCapture(params) {
+	const { config, deepsightService } = params;
+	const provider = new IdCaptureProvider();
+	await provider.initialize({});
+	provider.setThresholds(resolveIdCaptureThresholds(config));
+	if (config.settings) provider.setSettings({
+		...DEFAULT_ID_CAPTURE_SETTINGS,
+		...config.settings
+	});
+	if (deepsightService && !params.stream) try {
+		await deepsightService.performPrcCheck({ constraints: getPrcCameraConstraints() });
+	} catch {}
+	const { stream, fallbackLevel } = params.stream ? {
+		stream: params.stream,
+		fallbackLevel: params.cameraFallbackLevel
+	} : await getIdCameraStream();
+	const videoTrack = stream.getVideoTracks()[0];
+	let captureResolution;
+	if (videoTrack) {
+		const settings = videoTrack.getSettings();
+		if (typeof settings.width === "number" && typeof settings.height === "number") captureResolution = `${settings.width}x${settings.height}`;
+	}
+	if (deepsightService && videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
+	return {
+		stream,
+		provider,
+		captureResolution,
+		cameraFallbackLevel: fallbackLevel
+	};
+}
+function stopStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+function validateUploadResponse(response, sessionState) {
+	if (response.failReason === "ID_TYPE_UNACCEPTABLE") return {
+		error: true,
+		message: "ID type is not acceptable",
+		messageDescription: "Please use a valid ID type",
+		errorKey: ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE
+	};
+	if (response.failReason === "WRONG_DOCUMENT_SIDE") return {
+		error: true,
+		message: "Wrong side of document",
+		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
+		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
+	};
+	if (!response.classification) return {
+		error: true,
+		message: "ID classification failed",
+		errorKey: ID_ERROR_CODES.CLASSIFICATION_FAILED
+	};
+	const sharpnessThreshold = getDeviceClass() === "desktop" ? -1 : SHARPNESS_THRESHOLD;
+	if (response.sharpness !== void 0 && sharpnessThreshold >= 0 && response.sharpness < sharpnessThreshold) return {
+		error: true,
+		message: "Image is not sharp enough",
+		messageDescription: "Please ensure the image is clear and well-focused",
+		errorKey: ID_ERROR_CODES.LOW_SHARPNESS
+	};
+	if (response.glare !== void 0 && response.glare < GLARE_THRESHOLD && !sessionState?.skipGlareFront && !sessionState?.skipGlareBack) return {
+		error: true,
+		message: "Glare detected on ID",
+		messageDescription: "Please avoid bright reflections on your ID",
+		errorKey: ID_ERROR_CODES.GLARE_DETECTED
+	};
+}
+async function getExtraImages(params) {
+	const extraImages = params.ageAssurance ? [params.type === "back" ? "croppedBackID" : "croppedFrontID"] : [];
+	try {
+		const res = await api.post(endpoints.getImages, { images: ["croppedIDFace", ...extraImages] }, { signal: params.signal });
+		if (!res.ok) throw new Error(`Failed to get extra images: ${res.status}`);
+		return res.data ?? {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	} catch {
+		return {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	}
+}
+const getRealQualityValue = (value) => (1 - value) * 100;
+async function uploadIdImage(params) {
+	const { type, image, onProgress, signal, metadata, ageAssurance, glare, sharpness, shouldSkipGlareBack, analyticsProvider, imageData, isSecondId, onlyFront, extractIdFace } = params;
+	let finalMetadata = metadata;
+	if (analyticsProvider && imageData) try {
+		await analyticsProvider.analyzeFrame(imageData);
+		analyticsProvider.update();
+		finalMetadata = analyticsProvider.getMetadata();
+	} catch (error) {
+		console.warn("[IdCapture] Analytics failed:", error);
+	}
+	const endpoint = getUploadEndpoint(type, isSecondId);
+	const body = {
+		base64Image: image,
+		metadata: finalMetadata
+	};
+	const queryParams = { imageType: "id" };
+	if (onlyFront && type === "front") queryParams.onlyFront = true;
+	if (shouldSkipGlareBack && type === "back") queryParams.glare = 0;
+	else if (glare !== void 0) queryParams.glare = getRealQualityValue(glare);
+	if (sharpness !== void 0) queryParams.sharpness = getRealQualityValue(sharpness);
+	if (extractIdFace === false && type === "front") queryParams.extractIdFace = false;
+	try {
+		const res = await api.post(endpoint, body, {
+			signal,
+			query: queryParams,
+			onUploadProgress: onProgress
+		});
+		if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+		const response = res.data;
+		const extraImages = await getExtraImages({
+			type,
+			ageAssurance,
+			signal
+		});
+		const fullResponse = {
+			...response,
+			originalImage: image,
+			frontIdImage: type === "front" ? image : void 0,
+			backIdImage: extraImages.croppedBackID,
+			...extraImages
+		};
+		onProgress?.(100);
+		return fullResponse;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
+	}
+}
+function buildStandardResolution(width, height) {
+	return height > width ? {
+		width: 1080,
+		height: 1920
+	} : {
+		width: 1920,
+		height: 1080
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return "1080x1920";
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") {
+		const standard = buildStandardResolution(width, height);
+		return `${standard.width}x${standard.height}`;
+	}
+	return "1080x1920";
+}
+function preloadIdRecordingProvider(config) {
+	if (config.enableIdRecording !== true) return;
+	preloadOpenViduProvider();
+}
+async function createOpenViduRecordingProvider() {
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-Du98qevC.esm.js");
+	return new OpenViduRecordingProvider();
+}
+async function startRecordingSession(params) {
+	if (params.config.enableIdRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
+	const clonedStream = params.stream.clone();
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession(params.type);
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: params.type,
+		resolution,
+		hasAudio
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+function stopRecording(session) {
+	(async () => {
+		try {
+			await stopRecording$1(session.videoRecordingId);
+		} finally {
+			await session.connection.disconnect();
+		}
+	})();
+}
+async function processId(isSecondId = false, queueName = "", signal) {
+	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
+	const url = queueName ? `${endpoint}?queueName=${queueName}` : endpoint;
+	return { isDocumentExpired: (await api.post(url, {}, { signal })).data?.isDocumentExpired ?? false };
+}
+/**
+* Upload a user-selected image as front / back / passport ID.
+*
+* Uses the same request shape as the live-camera path (`uploadIdImage`):
+* JSON body `{ base64Image }` with default application/json Content-Type,
+* `captureType=UPLOAD` query param, `retry=true` when retrying.
+* Back is POSTed to `/omni/add/back-id/v2` (or `/omni/add/back-second-id/v2`
+* when `isSecondId`); front and passport go to `/omni/add/front-id/v2` (or
+* `/omni/add/front-second-id/v2` when `isSecondId`).
+*
+* The v2 endpoints reject raw `image/jpeg` bodies with 415, so the caller
+* must convert the File to base64 before calling this service.
+*/
+async function uploadManualIdFile(params) {
+	const { side, base64Image, retry, onlyFront, signal, isSecondId, extractIdFace } = params;
+	const endpoint = getUploadEndpoint(side === "back" ? "back" : "front", isSecondId);
+	const queryParams = { captureType: "UPLOAD" };
+	if (retry) queryParams.retry = true;
+	if (onlyFront && side === "front") queryParams.onlyFront = true;
+	if (extractIdFace === false && side !== "back") queryParams.extractIdFace = false;
+	const res = await api.post(endpoint, { base64Image }, {
+		signal,
+		query: queryParams
+	});
+	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+/**
+* UTF-8-safe base64 encoding of a decoded barcode payload. Uses the browser
+* `TextEncoder` + `btoa` (always available in the SDK's target environment) so
+* non-ASCII payloads survive `btoa`, which only accepts Latin-1.
+*/
+function barcodeToBase64(raw) {
+	const bytes = new TextEncoder().encode(raw);
+	let binary = "";
+	bytes.forEach((byte) => {
+		binary += String.fromCharCode(byte);
+	});
+	return btoa(binary);
+}
+/**
+* US Smart Capture: submits a decoded PDF417 barcode to
+* `POST /omni/add/barcode/v3`. The response drives the downstream front-capture
+* and Process ID skips (`forceFrontIdCapture` / `idValidationCompleted`).
+* Mirrors SDK 1's `addBarcode`. Throws (carrying `status`/`data`) on a non-OK
+* response so the caller can fall back to a full-frame upload. The
+* hardware-id token is injected by the shared `api` layer, as in `uploadIdImage`.
+*/
+async function addBarcode(params) {
+	const { rawBarcode, processId = true, metrics, signal } = params;
+	const body = { base64Barcode: barcodeToBase64(rawBarcode) };
+	if (metrics) {
+		body.pdf417RowNumber = metrics.rowNumber;
+		body.pdf417ColumnNumber = metrics.columnNumber;
+		body.pdf417CodewordLengthInPixelsMin = metrics.codewordLengthInPixelsMin;
+		body.pdf417CodewordLengthInPixelsMax = metrics.codewordLengthInPixelsMax;
+		body.pdf417CorrectedErrorsCount = metrics.correctedErrorsCount;
+		body.ecLevel = metrics.ecLevel;
+	}
+	const res = await api.post(endpoints.addBarcode, body, {
+		query: { processId },
+		signal
+	});
+	if (!res.ok) throw Object.assign(/* @__PURE__ */ new Error(`POST ${endpoints.addBarcode} failed: ${res.status} ${res.statusText}`), {
+		status: res.status,
+		data: res.data
+	});
+	return res.data;
+}
+//#endregion
+export { processId as a, stopStream as c, validateUploadResponse as d, ID_ERROR_CODES as f, getIdCameraStream as g, CAPTURE_RESULT_PREVIEW as h, preloadIdRecordingProvider as i, uploadIdImage as l, resolveIdCaptureThresholds as m, barcodeToBase64 as n, startRecordingSession as o, resolveCaptureResultPreviewTreatment as p, initializeIdCapture as r, stopRecording as s, addBarcode as t, uploadManualIdFile as u };