@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/selfie.esm.js

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

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

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

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