@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/face-match.esm.js

@@ -0,0 +1,173 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as faceMatchMachine } from "./faceMatchStateMachine-DNFrxTFS.esm.js";
+
+//#region src/modules/face-match/faceMatchActor.ts
+function createFaceMatchActor(options) {
+	return createActor(faceMatchMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/face-match/faceMatchManager.ts
+/**
+* @module @incodetech/core/face-match
+*
+* Face match module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The face match manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless face match with auto-skip
+* ```typescript
+* import { createFaceMatchManager } from '@incodetech/core/face-match';
+* import { setup } from '@incodetech/core';
+*
+* // 1. Configure the SDK (required before using any module)
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* // 2. Create the face match manager
+* const faceMatchManager = createFaceMatchManager({
+*   config: {
+*     matchingType: 'selfieVsId',
+*     disableFaceMatchAnimation: true,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* faceMatchManager.subscribe((state) => {
+*   console.log('Face match state:', state.status);
+*   if (state.status === 'finished') {
+*     console.log('Face match complete!', state.matched);
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* faceMatchManager.load();
+*
+* // 5. Auto-completes when disableFaceMatchAnimation is true
+* // Or call faceMatchManager.continue() after animation in custom UI
+*
+* // 6. Clean up when done
+* faceMatchManager.stop();
+* ```
+*
+* @example Headless face match with custom UI
+* ```typescript
+* const faceMatchManager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: false },
+* });
+*
+* faceMatchManager.subscribe((state) => {
+*   if (state.status === 'animating') {
+*     // Render your custom animation
+*     renderAnimation(state.images, state.result);
+*   }
+*   if (state.status === 'result') {
+*     // Show result and wait for user to click continue
+*     showResult(state.matched);
+*   }
+* });
+*
+* faceMatchManager.load();
+* // When animation completes in your UI:
+* faceMatchManager.animationComplete();
+* // When user clicks continue:
+* faceMatchManager.continue();
+* ```
+*/
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("animating")) return {
+		status: "animating",
+		images: context.images,
+		result: context.result
+	};
+	if (typedSnapshot.matches("result")) return {
+		status: "result",
+		images: context.images,
+		result: context.result,
+		matched: context.result.matched
+	};
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		matched: context.result?.matched ?? null
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		animationComplete() {
+			actor.send({ type: "ANIMATION_COMPLETE" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a face match manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for face comparison
+* with optional animation display.
+*
+* @param options - Configuration options
+* @param options.config - Face match configuration
+* @param options.config.matchingType - Which images to compare (default: 'selfieVsId')
+* @param options.config.disableFaceMatchAnimation - Skip animation and auto-complete (default: false)
+*
+* @returns Face match manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createFaceMatchManager({
+*   config: { matchingType: 'selfieVsId', disableFaceMatchAnimation: true },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* // Auto-completes when disableFaceMatchAnimation is true
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createFaceMatchManager({ config }));
+*
+* if (state.status === 'animating') {
+*   return <Animation images={state.images} />;
+* }
+* ```
+*/
+function createFaceMatchManager(options) {
+	return createManager({
+		actor: createFaceMatchActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.faceMatch)
+	});
+}
+
+//#endregion
+export { createFaceMatchManager, faceMatchMachine };

package/dist/faceCaptureManagerFactory-Dh2PdGlF.esm.js

@@ -0,0 +1,290 @@
+import { n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-D6-e4vok.esm.js";
+import { c as createManager } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/internal/faceCapture/faceCaptureManagerFactory.ts
+function getPermissionStatus(snapshot) {
+	if (!snapshot.matches("permissions")) return;
+	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
+	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
+	if (snapshot.matches({ permissions: "denied" })) return "denied";
+}
+function getCaptureStatus(snapshot) {
+	if (snapshot.matches({ capture: "initializing" })) return "initializing";
+	if (snapshot.matches({ capture: "detecting" })) return "detecting";
+	if (snapshot.matches({ capture: "capturing" })) return "capturing";
+	if (snapshot.matches({ capture: "capturingManual" })) return "capturing";
+	if (snapshot.matches({ capture: "preparingUpload" })) return "uploading";
+	if (snapshot.matches({ capture: "uploading" })) return "uploading";
+	if (snapshot.matches({ capture: "validatingUpload" })) return "uploading";
+	if (snapshot.matches({ capture: "uploadError" })) return "uploadError";
+	if (snapshot.matches({ capture: "success" })) return "success";
+}
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("tutorial")) return {
+		status: "tutorial",
+		ageAssurance: context.config?.ageAssurance === true
+	};
+	if (snapshot.matches("closed")) return { status: "closed" };
+	if (snapshot.matches("permissions")) {
+		const permissionStatus = getPermissionStatus(snapshot);
+		if (permissionStatus === void 0) return {
+			status: "permissions",
+			permissionStatus: "idle"
+		};
+		return {
+			status: "permissions",
+			permissionStatus
+		};
+	}
+	if (snapshot.matches("capture")) return {
+		status: "capture",
+		captureStatus: getCaptureStatus(snapshot) ?? "initializing",
+		stream: context.stream,
+		detectionStatus: context.detectionStatus ?? "idle",
+		debugFrame: context.debugFrame,
+		attemptsRemaining: context.attemptsRemaining ?? 0,
+		uploadError: context.uploadError,
+		assistedOnboarding: context.config?.assistedOnboarding ?? false,
+		ageAssurance: context.config?.ageAssurance === true
+	};
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		processResponse: context.processResponse
+	};
+	if (snapshot.matches("error")) {
+		const errorValue = context.error;
+		return {
+			status: "error",
+			error: typeof errorValue === "string" ? errorValue : errorValue ? errorValue.message : "Unknown error"
+		};
+	}
+	return { status: "idle" };
+}
+function getFaceCaptureTutorialScreen(snapshot) {
+	if (snapshot.context?.config?.ageAssurance === true) return "faceCapture.tutorial.ageAssurance";
+	if (typeof snapshot.value === "object" && snapshot.value !== null) {
+		const tutorialValue = snapshot.value.tutorial;
+		if (typeof tutorialValue === "object" && tutorialValue !== null && "initializingCamera" in tutorialValue) return "faceCapture.tutorial.loading";
+	}
+	return "faceCapture.tutorial.default";
+}
+function getCapturingScreen(detectionStatus) {
+	switch (detectionStatus) {
+		case "getReady":
+		case "getReadyFinished": return "faceCapture.capturing.getReady";
+		case "dark": return "faceCapture.capturing.tooDark";
+		case "tooBright": return "faceCapture.capturing.tooBright";
+		case "tooClose": return "faceCapture.capturing.moveAway";
+		case "tooFar": return "faceCapture.capturing.moveCloser";
+		case "moveLeft": return "faceCapture.capturing.moveLeft";
+		case "moveRight": return "faceCapture.capturing.moveRight";
+		case "blur":
+		case "centerFace":
+		case "noFace":
+		case "tooManyFaces": return "faceCapture.capturing.alignFace";
+		case "faceAngle":
+		case "lookAtCamera": return "faceCapture.capturing.lookAtCamera";
+		case "eyesClosed": return "faceCapture.capturing.eyesClosed";
+		case "faceMask": return "faceCapture.capturing.maskDetected";
+		case "lenses": return "faceCapture.capturing.glassesDetected";
+		case "headWear": return "faceCapture.capturing.hatDetected";
+		case "faceOcclusion": return "faceCapture.capturing.faceOcclusion";
+		case "manualCapture": return "faceCapture.manualCapture.default";
+		case "capturing": return "faceCapture.loading.processing";
+		case "detecting":
+		case "idle":
+		case "offline": return "faceCapture.genericErrors.noConnection";
+		case "success":
+		case "error":
+		default: return "faceCapture.capturing.initiatingState";
+	}
+}
+function getResultErrorScreen(errorCode, attemptsRemaining) {
+	const exhaustedSuffix = attemptsRemaining === 0 ? "Exhausted" : "";
+	switch (errorCode) {
+		case "LENSES_ERROR":
+		case "LENSES_DETECTED": return `faceCapture.resultError.lensesDetected${exhaustedSuffix}`;
+		case "BRIGHTNESS_ERROR": return `faceCapture.resultError.tooBright${exhaustedSuffix}`;
+		case "MASK_ERROR":
+		case "FACE_MASK_DETECTED": return `faceCapture.resultError.faceMaskDetected${exhaustedSuffix}`;
+		case "FACE_TOO_DARK":
+		case "TOO_DARK_ERROR": return `faceCapture.resultError.tooDark${exhaustedSuffix}`;
+		case "CLOSED_EYES_ERROR":
+		case "CLOSED_EYES_DETECTED": return `faceCapture.resultError.eyesClosed${exhaustedSuffix}`;
+		case "HEAD_COVER_ERROR":
+		case "HEAD_COVER_DETECTED": return `faceCapture.resultError.headCovered${exhaustedSuffix}`;
+		case "FACE_OCCLUDED": return `faceCapture.resultError.faceOcclusion${exhaustedSuffix}`;
+		case "TOO_BLURRY_ERROR":
+		case "FACE_TOO_BLURRY":
+		case "BAD_PHOTO_QUALITY":
+		case "SELFIE_IMAGE_LOW_QUALITY": return `faceCapture.resultError.lowQuality${exhaustedSuffix}`;
+		case "SERVER_ERROR":
+		case "PROCESSING_ERROR":
+		case "BAD_REQUEST": return `faceCapture.resultError.processingFailed${exhaustedSuffix}`;
+		case "FACE_NOT_FOUND":
+		case "MULTIPLE_FACES":
+		case "FACE_CROPPING_FAILED":
+		case "FACE_TOO_SMALL":
+		case "LIVENESS_ERROR":
+		default: return `faceCapture.resultError.faceNotAligned${exhaustedSuffix}`;
+	}
+}
+function getCaptureSubstateScreen(snapshot) {
+	const { value, context } = snapshot;
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "checkingDeepsight":
+		case "initializingDeepsight":
+		case "checkingStream":
+		case "initializing": return "faceCapture.capturing.initiatingState";
+		case "detecting": return getCapturingScreen(context?.detectionStatus);
+		case "capturing": return "faceCapture.loading.processing";
+		case "capturingManual": return "faceCapture.manualCapture.default";
+		case "preparingUpload":
+		case "uploading":
+		case "validatingUpload": return "faceCapture.loading.uploading";
+		case "uploadError": return getResultErrorScreen(context?.uploadError, context?.attemptsRemaining);
+		case "success": return "faceCapture.resultSuccess.default";
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("uploading")) return "faceCapture.loading.uploading";
+		if (substates.includes("uploadError")) return getResultErrorScreen(context?.uploadError, context?.attemptsRemaining);
+		if (substates.includes("success")) return "faceCapture.resultSuccess.default";
+	}
+	return "faceCapture.capturing.initiatingState";
+}
+function getAuthFaceCaptureSubstateScreen(snapshot) {
+	const { value } = snapshot;
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "preparingUpload":
+		case "uploading":
+		case "validatingUpload": return eventScreenNames.authFaceUpload;
+		case "uploadError": return eventScreenNames.authFaceError;
+		case "success": return eventScreenNames.authFaceUploadSuccess;
+		case "checkingDeepsight":
+		case "initializingDeepsight":
+		case "checkingStream":
+		case "initializing":
+		case "detecting":
+		case "capturing":
+		case "capturingManual": return eventScreenNames.authFace;
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("uploading") || substates.includes("validatingUpload")) return eventScreenNames.authFaceUpload;
+		if (substates.includes("uploadError")) return eventScreenNames.authFaceError;
+		if (substates.includes("success")) return eventScreenNames.authFaceUploadSuccess;
+	}
+	return eventScreenNames.authFace;
+}
+function getTopLevelState(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "object") return Object.keys(value)[0];
+}
+function getAuthFaceScreenName(snapshot) {
+	const { value } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = getTopLevelState(value);
+	if (topLevel === void 0) return void 0;
+	switch (topLevel) {
+		case "tutorial": return eventScreenNames.authFaceTutorial;
+		case "capture": return getAuthFaceCaptureSubstateScreen(snapshot);
+		case "finished": return eventScreenNames.authFaceUploadSuccess;
+		case "error": return eventScreenNames.authFaceUploadFailed;
+		case "idle":
+		case "loading":
+		case "permissions":
+		case "processing":
+		case "closed":
+		default: return eventScreenNames.authFace;
+	}
+}
+function getFaceCaptureScreenName(snapshot, moduleName) {
+	if (moduleName === eventModuleNames.authFace || moduleName === eventModuleNames.authentication) return getAuthFaceScreenName(snapshot);
+	const { value } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = getTopLevelState(value);
+	if (topLevel === void 0) return void 0;
+	switch (topLevel) {
+		case "idle": return "faceCapture.loading.processing";
+		case "loading": return "faceCapture.loading.processing";
+		case "tutorial": return getFaceCaptureTutorialScreen(snapshot);
+		case "permissions": return "faceCapture.tutorial.default";
+		case "capture": return getCaptureSubstateScreen(snapshot);
+		case "processing": return "faceCapture.loading.processing";
+		case "finished": return "faceCapture.resultSuccess.default";
+		case "closed": return "faceCapture.closed";
+		case "error": return "faceCapture.resultError.processingFailed";
+		default: return `faceCapture.${topLevel}`;
+	}
+}
+function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
+	const snapshot = actor.getSnapshot();
+	snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			trackElementClicked?.("retryCapture");
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "MANUAL_CAPTURE" });
+		}
+	};
+}
+function getFaceCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.uploadError;
+	if (typeof errorCode !== "string" || errorCode.length === 0) return;
+	return { errorCode };
+}
+function createFaceCaptureManagerFromActor(actor, moduleName) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(moduleName, {
+			getEventScreenName: (snapshot) => getFaceCaptureScreenName(snapshot, moduleName),
+			getErrorPayload: getFaceCaptureErrorPayload
+		})
+	});
+}
+
+//#endregion
+export { createFaceCaptureManagerFromActor as t };