@incodetech/core 2.0.0 → 2.0.1

package/dist/selfie.esm.js

@@ -0,0 +1,146 @@
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import { a as fromPromise, r as assign, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./deepsightService-O74l4Y__.esm.js";
+import { f as processFace } from "./recordingService-Ig2UgbLv.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import "./backCameraStream-DMdMeGk2.esm.js";
+import "./getBrowser-BSXUTWXw.esm.js";
+import "./stats-CIfiPzb1.esm.js";
+import "./getDeviceClass-BSntT9_j.esm.js";
+import "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./permissionServices-D_i6nzEw.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-D76whWEf.esm.js";
+import { t as createSelfieManager } from "./selfieManager-Duisl7qN.esm.js";
+import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-rc6kBHo5.esm.js";
+
+//#region src/modules/selfie/selfieCaptureOnlyStateMachine.ts
+/**
+* Performs local finalization of a captured face frame: stops local video
+* recording (if any), runs deepsight metadata extraction, and assembles the
+* rich payload delivered to the integrator's `onCapture` callback.
+*/
+async function finalizeFaceCaptureOnly(ctx, signal) {
+	const canvas = ctx.capturedImage;
+	if (!canvas) throw new Error("selfieCaptureOnly: no captured image");
+	let videoBase64;
+	try {
+		videoBase64 = (await ctx.recordingService?.stopAndGetVideo())?.videoBase64;
+	} catch {
+		videoBase64 = void 0;
+	}
+	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+	let metadata = "";
+	try {
+		if (ctx.deepsightService) {
+			const imageData = canvas.getImageData();
+			if (imageData) await ctx.deepsightService.analyzeFrame(imageData);
+			if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+			metadata = ctx.deepsightService.getMetadata();
+		}
+	} catch (error) {
+		if (error?.name === "AbortError") throw error;
+		metadata = "";
+	}
+	const imageBase64 = canvas.getBase64Image() ?? "";
+	const blobData = canvas.getBlobData();
+	if (!blobData) throw new Error("selfieCaptureOnly: failed to build image blob");
+	return {
+		imageBase64,
+		blob: blobData.blob,
+		url: blobData.url,
+		metadata,
+		videoBase64
+	};
+}
+const _selfieCaptureOnlyMachine = faceCaptureMachine.provide({
+	actors: {
+		prepareFaceUpload: fromPromise(async () => ({
+			encryptedBase64Image: "",
+			recordingId: null
+		})),
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			return await finalizeFaceCaptureOnly(input, signal);
+		}),
+		processFace: fromPromise(async () => ({}))
+	},
+	actions: { setUploadResponseFromEvent: assign({ captureOnlyResult: ({ event }) => event.output }) },
+	guards: {
+		hasUploadValidationError: () => false,
+		isTerminalUploadError: () => false
+	}
+});
+/**
+* Selfie state machine variant for the captureOnly flow. Shares the full base
+* face-capture state tree; only the upload/process step is local instead of
+* remote.
+*/
+const selfieCaptureOnlyMachine = _selfieCaptureOnlyMachine;
+
+//#endregion
+//#region src/modules/selfie/selfieCaptureOnlyActor.ts
+function createSelfieCaptureOnlyActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieCaptureOnlyMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/selfie/selfieCaptureOnlyManager.ts
+/**
+* Wraps a selfie captureOnly actor with a manager that fires `onCapture`
+* exactly once when the actor reaches the `finished` final state. XState's
+* `complete` lifecycle fires for both `finished` and `closed` (both are
+* `type: 'final'` per the SDK terminal-state convention) — gating on
+* `finished` prevents a user-quit mid-capture from delivering a partial
+* payload.
+*/
+function attachOnCaptureFiring(actor, config) {
+	const subscription = actor.subscribe({ complete: () => {
+		const snapshot = actor.getSnapshot();
+		if (!snapshot.matches("finished")) return;
+		const payload = snapshot.context.captureOnlyResult;
+		if (!payload) return;
+		const response = { image: payload };
+		invokeOnCaptureCallback(config.onCapture, response, eventModuleNames.selfie);
+	} });
+	return () => subscription.unsubscribe();
+}
+function createSelfieCaptureOnlyManagerFromActor(actor, config) {
+	const unsubscribe = attachOnCaptureFiring(actor, config);
+	const manager = createFaceCaptureManagerFromActor(actor, eventModuleNames.selfie);
+	return {
+		...manager,
+		stop: () => {
+			unsubscribe();
+			manager.stop();
+		}
+	};
+}
+/**
+* Creates a captureOnly selfie manager.
+*
+* Unlike {@link createSelfieManager}, the captured face image is delivered
+* locally to the integrator's `onCapture` callback instead of being uploaded
+* to the Incode backend. `onCapture` is required.
+*/
+function createSelfieCaptureOnlyManager(options) {
+	return createSelfieCaptureOnlyManagerFromActor(createSelfieCaptureOnlyActor(options), options.config);
+}
+
+//#endregion
+export { createSelfieCaptureOnlyManager, createSelfieCaptureOnlyManagerFromActor, createSelfieManager, processFace, selfieCaptureOnlyMachine, selfieMachine };

package/dist/selfieManager-D0lSgd-J.d.ts

@@ -0,0 +1,68 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { c as SelfieActor, n as FaceCaptureManagerState, s as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-yqtpxjnN.js";
+
+//#region src/modules/selfie/selfieUploadService.d.ts
+type ProcessFaceImageType = 'selfie' | 'videoSelfie';
+type ProcessFaceResponse = {
+  faceMatch: boolean;
+  confidence: number;
+  existingUser: boolean;
+};
+declare function processFace(imageType?: ProcessFaceImageType, signal?: AbortSignal): Promise<ProcessFaceResponse>;
+//#endregion
+//#region src/modules/selfie/selfieManager.d.ts
+type SelfieState = FaceCaptureManagerState;
+declare function createSelfieManagerFromActor(actor: SelfieActor): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+/**
+ * Creates a selfie manager instance for handling selfie capture flow.
+ *
+ * The selfie manager provides:
+ * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+ * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+ * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+ * - Camera stream access when in `capture` state
+ * - Detection status feedback during face detection
+ * - Attempt tracking with `attemptsRemaining`
+ *
+ * @param options - Configuration for the selfie actor
+ * @param options.config - The selfie module configuration from the flow
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const selfieManager = createSelfieManager({ config: selfieConfig });
+ *
+ * selfieManager.subscribe((state) => {
+ *   if (state.status === 'capture') {
+ *     console.log('Camera ready:', state.stream);
+ *     console.log('Detection status:', state.detectionStatus);
+ *   }
+ * });
+ *
+ * selfieManager.load();
+ * ```
+ */
+declare function createSelfieManager(options: CreateSelfieActorOptions): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+type SelfieManager = FaceCaptureManager;
+//#endregion
+export { ProcessFaceResponse as a, createSelfieManagerFromActor as i, SelfieState as n, processFace as o, createSelfieManager as r, SelfieManager as t };

package/dist/selfieManager-Duisl7qN.esm.js

@@ -0,0 +1,60 @@
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import { n as eventModuleNames } from "./events-D6-e4vok.esm.js";
+import { s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-D76whWEf.esm.js";
+
+//#region src/modules/selfie/selfieActor.ts
+function createSelfieActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieMachine, { input: {
+		config: options.config,
+		dependencies,
+		authHint: options.authHint
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/selfie/selfieManager.ts
+function createSelfieManagerFromActor(actor) {
+	return createFaceCaptureManagerFromActor(actor, eventModuleNames.faceCapture);
+}
+/**
+* Creates a selfie manager instance for handling selfie capture flow.
+*
+* The selfie manager provides:
+* - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+* - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+* - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+* - Camera stream access when in `capture` state
+* - Detection status feedback during face detection
+* - Attempt tracking with `attemptsRemaining`
+*
+* @param options - Configuration for the selfie actor
+* @param options.config - The selfie module configuration from the flow
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const selfieManager = createSelfieManager({ config: selfieConfig });
+*
+* selfieManager.subscribe((state) => {
+*   if (state.status === 'capture') {
+*     console.log('Camera ready:', state.stream);
+*     console.log('Detection status:', state.detectionStatus);
+*   }
+* });
+*
+* selfieManager.load();
+* ```
+*/
+function createSelfieManager(options) {
+	return createFaceCaptureManagerFromActor(createSelfieActor(options), eventModuleNames.faceCapture);
+}
+
+//#endregion
+export { createSelfieManagerFromActor as n, createSelfieManager as t };

package/dist/selfieStateMachine-D76whWEf.esm.js

@@ -0,0 +1,68 @@
+import { a as fromPromise, r as assign } from "./xstate.esm-B70JrNqo.esm.js";
+import { a as prepareOnDeviceFaceUpload, i as postOnDeviceFaceResults, n as defaultPrepareFaceUpload, r as isOnDeviceMode, t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
+import { f as processFace, m as FACE_ERROR_CODES, p as uploadSelfie } from "./recordingService-Ig2UgbLv.esm.js";
+
+//#region src/modules/selfie/selfieErrorUtils.ts
+const FACE_ERROR_CODE_VALUES = Object.values(FACE_ERROR_CODES);
+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
+//#region src/modules/selfie/selfieStateMachine.ts
+const _selfieMachine = faceCaptureMachine.provide({
+	actors: {
+		prepareFaceUpload: fromPromise(async ({ input }) => {
+			const ctx = input;
+			return isOnDeviceMode(ctx.config) ? prepareOnDeviceFaceUpload(ctx) : defaultPrepareFaceUpload(ctx);
+		}),
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			const ctx = input;
+			if (isOnDeviceMode(ctx.config)) return postOnDeviceFaceResults(ctx, signal);
+			return uploadSelfie({
+				encryptedBase64Image: ctx.encryptedBase64Image,
+				faceCoordinates: ctx.faceCoordinates,
+				metadata: ctx.deepsightService?.getMetadata(),
+				recordingId: ctx.uploadRecordingId,
+				signal
+			});
+		}),
+		processFace: fromPromise(async ({ input, signal }) => {
+			if (isOnDeviceMode(input.config)) return {};
+			return processFace("selfie", signal);
+		})
+	},
+	actions: { 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
+	}
+});
+/**
+* The selfie capture state machine.
+*
+* Note: Uses AnyStateMachine type for declaration file portability.
+* Type safety is ensured via the machine configuration.
+*/
+const selfieMachine = _selfieMachine;
+
+//#endregion
+export { selfieMachine as t };