@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/face-match.esm.js

@@ -1,173 +0,0 @@
-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

@@ -1,290 +0,0 @@
-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 };