@incodetech/core 2.3.2-rc.4 → 2.4.0-rc.0

package/dist/index-B8weJxmL.d.ts

@@ -1 +0,0 @@
-import "./Manager-CQQ99QOI.js";

package/dist/selfieErrorUtils-UiQ46EBa.esm.js

@@ -1,116 +0,0 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
-//#region src/modules/selfie/selfieUploadService.ts
-/**
-* Uploads a selfie image to the backend.
-*/
-async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId, imageType = "selfie", deepsightService }) {
-	try {
-		const payload = {
-			base64Image: encryptedBase64Image,
-			faceCoordinates: faceCoordinates ?? void 0,
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() },
-			metadata: metadata ?? void 0
-		};
-		const query = { imageType };
-		if (recordingId) query.recordingId = recordingId;
-		const res = await api.post(endpoints.selfie, payload, {
-			signal,
-			query
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
-		if (deepsightService) addDeviceStats({
-			frontIdStatsAnalysisStatus: "",
-			backIdStatsAnalysisStatus: "",
-			selfieStatsAnalysisStatus: deepsightService.getAnalysisStatus(),
-			motionStatus: deepsightService.getMotionStatus()
-		});
-		return res.data;
-	} catch (error) {
-		const errorCode = getFaceErrorCodeFromHttpError(error);
-		throw withTransportStatus(new Error(errorCode ?? FACE_ERROR_CODES.SERVER), error);
-	}
-}
-/**
-* Uploads a selfie the user picked from device storage. Same endpoint and
-* encryption as {@link uploadSelfie}, plus `captureType=UPLOAD`; there is no
-* camera, so no face coordinates, deepsight metadata or recording id.
-*/
-async function uploadManualSelfie({ base64Image, dependencies, imageType = "selfie", signal }) {
-	try {
-		const payload = {
-			base64Image: (await dependencies.getWasmUtil()).encryptImage(base64Image),
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() }
-		};
-		const res = await api.post(endpoints.selfie, payload, {
-			signal,
-			query: {
-				imageType,
-				captureType: "UPLOAD"
-			}
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
-		return res.data;
-	} catch (error) {
-		const errorCode = getFaceErrorCodeFromHttpError(error);
-		throw withTransportStatus(new Error(errorCode ?? FACE_ERROR_CODES.SERVER), error);
-	}
-}
-/**
-* Copies the HTTP status of `source` onto `target`. The code alone cannot say
-* whether the request got a verdict or never reached the backend — a network
-* failure and a 5xx both map to `SERVER_ERROR` — so a caller that retries
-* transport failures needs the status to survive this mapping.
-*/
-function withTransportStatus(target, source) {
-	if (typeof source === "object" && source !== null && "status" in source && typeof source.status === "number") return Object.assign(target, { status: source.status });
-	return target;
-}
-const getFaceErrorCodeFromHttpError = (error) => {
-	const err = error;
-	if (err.ok !== false || typeof err.status !== "number") return;
-	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
-	if (typeof err.data?.status !== "number") return FACE_ERROR_CODES.BAD_REQUEST;
-	return {
-		3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3006: FACE_ERROR_CODES.TOO_BLURRY,
-		3007: FACE_ERROR_CODES.TOO_DARK,
-		4010: FACE_ERROR_CODES.MULTIPLE_FACES,
-		4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-		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/selfieErrorUtils.ts
-const FACE_ERROR_CODE_VALUES = Object.values(FACE_ERROR_CODES);
-const isFaceErrorCode = (value) => {
-	return FACE_ERROR_CODE_VALUES.includes(value);
-};
-const getFaceErrorCodeFromUnknown = (value) => {
-	if (value instanceof Error && typeof value.message === "string") return isFaceErrorCode(value.message) ? value.message : void 0;
-	if (typeof value === "string") return isFaceErrorCode(value) ? value : void 0;
-};
-const validateUploadResponse = ({ config, response }) => {
-	if (!response) return FACE_ERROR_CODES.SERVER;
-	if (response.confidence !== 0) return FACE_ERROR_CODES.LIVENESS;
-	if (config.validateBrightness && !response.isBright) return FACE_ERROR_CODES.BRIGHTNESS;
-	if (config.validateLenses && response.hasLenses) return FACE_ERROR_CODES.LENSES;
-	if (config.validateFaceMask && response.hasFaceMask) return FACE_ERROR_CODES.MASK;
-	if (config.validateClosedEyes && response.hasClosedEyes) return FACE_ERROR_CODES.CLOSED_EYES;
-	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
-};
-//#endregion
-export { uploadSelfie as a, uploadManualSelfie as i, validateUploadResponse as n, processFace as r, getFaceErrorCodeFromUnknown as t };

package/dist/selfieStateMachine-CtMCi4KZ.esm.js

@@ -1,71 +0,0 @@
-import { i as assign } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as createDefaultProtectedFaceControllerActor, r as manualFaceUploadMachine, t as faceCaptureMachine } from "./faceCaptureSetup-DOrt8-Sn.esm.js";
-import { c as isOnDeviceMode } from "./FaceDetectionProvider-B5Fxc_y9.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-DnwTl1ad.esm.js";
-import { i as uploadManualSelfie, n as validateUploadResponse, r as processFace } from "./selfieErrorUtils-UiQ46EBa.esm.js";
-//#region src/modules/selfie/selfieStateMachine.ts
-/**
-* Validates like the camera path does: a 200 that reports lenses, a mask or
-* failed liveness is still a rejection, and throwing lets the child machine
-* spend a retry and map the code to copy.
-*/
-const manualUploadMachine = manualFaceUploadMachine.provide({ actors: {
-	protectedFaceController: createDefaultProtectedFaceControllerActor({
-		target: PROTECTED_CAPTURE_TARGET.selfie,
-		delivery: "protected"
-	}),
-	uploadFile: fromPromise(async ({ input, signal }) => {
-		const { base64Image, config, dependencies } = input;
-		const validationError = validateUploadResponse({
-			config,
-			response: await uploadManualSelfie({
-				base64Image,
-				dependencies,
-				signal
-			})
-		});
-		if (validationError) throw new Error(validationError);
-	})
-} });
-/**
-* The selfie capture state machine.
-*
-* Note: Uses AnyStateMachine type for declaration file portability.
-* Type safety is ensured via the machine configuration.
-*/
-const selfieMachine = faceCaptureMachine.provide({
-	actors: {
-		manualUploadMachine,
-		processFace: fromPromise(async ({ input, signal }) => {
-			const ctx = input;
-			if (isOnDeviceMode(ctx.config)) return {};
-			if (ctx.config.skipProcessFace === true) return {};
-			return processFace("selfie", signal);
-		})
-	},
-	actions: {
-		prepareStreamForRetry: () => void 0,
-		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
-			if (isOnDeviceMode(context.config)) return;
-			return validateUploadResponse({
-				config: context.config,
-				response: context.uploadResponse
-			}) ?? FACE_ERROR_CODES.SERVER;
-		} })
-	},
-	guards: {
-		hasUploadValidationError: ({ context }) => {
-			if (isOnDeviceMode(context.config)) return false;
-			return validateUploadResponse({
-				config: context.config,
-				response: context.uploadResponse
-			}) !== void 0;
-		},
-		isTerminalUploadError: () => false,
-		hasManualUploadEnabled: ({ context }) => context.config.manualUploadSelfieCapture === true
-	}
-});
-//#endregion
-export { selfieMachine as t };

package/dist/types-BN5RPPIZ.esm.js

@@ -1,34 +0,0 @@
-//#region src/internal/faceCapture/types.ts
-const FACE_ERROR_CODES = {
-	FACE_OCCLUDED: "FACE_OCCLUDED",
-	LIVENESS: "LIVENESS_ERROR",
-	BRIGHTNESS: "BRIGHTNESS_ERROR",
-	LENSES: "LENSES_ERROR",
-	MASK: "MASK_ERROR",
-	CLOSED_EYES: "CLOSED_EYES_ERROR",
-	HEAD_COVER: "HEAD_COVER_ERROR",
-	SERVER: "SERVER_ERROR",
-	FACE_NOT_FOUND: "FACE_NOT_FOUND",
-	MULTIPLE_FACES: "MULTIPLE_FACES",
-	TOO_BLURRY: "TOO_BLURRY_ERROR",
-	TOO_DARK: "TOO_DARK_ERROR",
-	USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED",
-	SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED",
-	FACE_TOO_DARK: "FACE_TOO_DARK",
-	LENSES_DETECTED: "LENSES_DETECTED",
-	FACE_MASK_DETECTED: "FACE_MASK_DETECTED",
-	CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED",
-	HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED",
-	FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED",
-	FACE_TOO_SMALL: "FACE_TOO_SMALL",
-	FACE_TOO_BLURRY: "FACE_TOO_BLURRY",
-	BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY",
-	PROCESSING_ERROR: "PROCESSING_ERROR",
-	BAD_REQUEST: "BAD_REQUEST",
-	NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER",
-	HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED",
-	SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY",
-	NO_MORE_ATTEMPTS: "NO_MORE_ATTEMPTS"
-};
-//#endregion
-export { FACE_ERROR_CODES as t };

package/dist/types-Bt9RuRqt.d.ts

@@ -1,6 +0,0 @@
-import { i as FlowModuleConfig } from "./types-C1g9itHE.js";
-import { t as BaseFaceCaptureConfig } from "./types-ESdtnHtg.js";
-//#region src/modules/authentication/types.d.ts
-type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
-//#endregion
-export { AuthenticationConfig as t };

package/dist/virtualCameraCheck-Cjab7FTI.esm.js

@@ -1,48 +0,0 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
-import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-//#region src/internal/virtualCameraCheck.ts
-const frameSources = {
-	front: "FRONT_ID",
-	back: "BACK_ID",
-	selfie: "SELFIE"
-};
-/**
-* 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) logFrame({
-			source,
-			base64Image,
-			token
-		});
-	}
-	if (output.itr === true) {
-		addDeviceStats({ virtualCameraDetected: true });
-		wasmUtil.setZc("FAIL");
-	} else if (output.itr === false) wasmUtil.setZc("PASS");
-}
-//#endregion
-export { runVirtualCameraCheck as n, frameSources as t };