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

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 };