@incodetech/core 0.0.0-dev-20260226-d2d561c → 0.0.0-dev-20260226-4cb58f5

package/dist/authentication.d.ts

@@ -1,10 +1,11 @@
-import "./types-ee3LkWku.js";
-import "./warmup-BUv67ifS.js";
-import { a as FaceCaptureDependencies, n as FaceCaptureManagerState, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CWGzTGlG.js";
-import { t as Manager } from "./Manager-DM1NlCX4.js";
-import { t as ActorRefFrom } from "./Actor-Chvt8rE9.js";
-import { t as AnyStateMachine } from "./StateMachine-B7tKroZs.js";
-import { r as FlowModuleConfig } from "./types-c0XgGLsM.js";
+import "./types-CLuw51tO.js";
+import "./warmup-BIZ_8rAa.js";
+import { a as FaceCaptureDependencies, n as FaceCaptureManagerState, r as BaseFaceCaptureConfig, t as FaceCaptureManager } from "./faceCaptureManagerFactory-5Blo_gz0.js";
+import { t as Manager } from "./Manager-C647XkuZ.js";
+import "./types-B3jgq_IJ.js";
+import { t as ActorRefFrom } from "./Actor-DYtyiYF1.js";
+import { t as AnyStateMachine } from "./StateMachine-B3u4LjaP.js";
+import { r as FlowModuleConfig } from "./types-Skrj9_8y.js";
 
 //#region src/modules/authentication/authenticationStateMachine.d.ts
 declare const _authenticationMachine: AnyStateMachine;

package/dist/authentication.esm.js

@@ -1,11 +1,12 @@
-import { d as addEvent, n as eventModuleNames } from "./events-h8K9H3OM.esm.js";
-import { l as getDeviceClass } from "./backCameraStream-CCvHeGHQ.esm.js";
-import { m as BrowserStorageProvider, r as WasmUtilProvider } from "./src-t0pt3B2r.esm.js";
-import { a as fromPromise, o as createActor, r as assign, t as endpoints } from "./endpoints-DXp63GM6.esm.js";
-import "./deepsightService-Bn05rSAa.esm.js";
-import { t as api } from "./api-DlSxxyGw.esm.js";
-import "./stats-GJMiTm5k.esm.js";
-import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManager, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-BflAHwmc.esm.js";
+import { d as addEvent, n as eventModuleNames } from "./events-DuBPhaxY.esm.js";
+import "./backCameraStream-Ly-xbK9L.esm.js";
+import { m as BrowserStorageProvider, r as WasmUtilProvider } from "./src-Bjg2C1oP.esm.js";
+import { a as fromPromise, o as createActor, r as assign, t as endpoints } from "./endpoints-BK1EjE1H.esm.js";
+import { c as getDeviceClass } from "./streamingEvents-BrVlVGe7.esm.js";
+import "./deepsightService-CpmpXOnj.esm.js";
+import { t as api } from "./api-J0YE3G-C.esm.js";
+import "./stats-Baxc8J0w.esm.js";
+import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManager, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-JLWm8_vt.esm.js";
 
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {

package/dist/{backCameraStream-CCvHeGHQ.esm.js → backCameraStream-Ly-xbK9L.esm.js}

@@ -1,111 +1,10 @@
-import { C as applyTrackConstraints, E as stopCameraStream, F as isIPhone14OrHigher, I as isSafari, M as isAndroid, P as isIOS, T as requestCameraAccess, b as queryCameraPermission, j as getUserAgent, k as getDeviceInfo, l as MotionSensorProvider, w as enumerateVideoDevices } from "./src-t0pt3B2r.esm.js";
-import { t as endpoints } from "./endpoints-DXp63GM6.esm.js";
-import { t as api } from "./api-DlSxxyGw.esm.js";
+import { C as applyTrackConstraints, E as stopCameraStream, F as isIPhone14OrHigher, I as isSafari, M as isAndroid, P as isIOS, T as requestCameraAccess, w as enumerateVideoDevices } from "./src-Bjg2C1oP.esm.js";
 
 //#region ../infra/src/capabilities/ITimerCapability.ts
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-//#endregion
-//#region src/internal/device/getBrowser.ts
-function getBrowser() {
-	const userAgent = getUserAgent();
-	if (!userAgent) return "other";
-	const ua = userAgent.toLowerCase();
-	if (ua.includes("edg/")) return "edge";
-	if (ua.includes("opr/") || ua.includes("opera")) return "opera";
-	if (ua.includes("chrome") && !ua.includes("edg/")) return "chrome";
-	if (ua.includes("firefox")) return "firefox";
-	if (ua.includes("safari") && !ua.includes("chrome")) return "safari";
-	return "other";
-}
-
-//#endregion
-//#region src/internal/device/getDeviceClass.ts
-function getDeviceClass() {
-	const { userAgent, platform, maxTouchPoints } = getDeviceInfo();
-	if (!userAgent) return "desktop";
-	const ua = userAgent.toLowerCase();
-	if (/iphone|ipad|ipod/.test(ua) || platform === "MacIntel" && maxTouchPoints > 1) return "ios";
-	if (/android/.test(ua)) return "android";
-	return "desktop";
-}
-
-//#endregion
-//#region src/internal/permissions/permissionServices.ts
-/**
-* Checks the current camera permission state without prompting the user.
-*/
-async function checkPermission() {
-	return queryCameraPermission();
-}
-/**
-* Requests motion sensor permission. Must be called during a user gesture on iOS.
-* Returns the permission result.
-*/
-async function requestMotionPermission() {
-	return new MotionSensorProvider().requestPermission();
-}
-/**
-* Requests camera permission by attempting to access the camera, then immediately
-* stops the obtained stream. Also requests motion sensor permission (required on iOS
-* to be called during a user gesture). This function does not keep or return the stream.
-*/
-async function requestPermission() {
-	try {
-		await requestMotionPermission();
-		stopCameraStream(await requestCameraAccess({ video: true }));
-		return "granted";
-	} catch (error) {
-		const name = error instanceof Error ? error.name : void 0;
-		if (name === "NotAllowedError" || name === "PermissionDeniedError") return "denied";
-		return "prompt";
-	}
-}
-
-//#endregion
-//#region src/internal/recordings/recordingsRepository.ts
-async function createRecordingSession(type) {
-	return (await api.post(endpoints.recordingCreateSessionV2, { type })).data;
-}
-async function startRecording(params) {
-	return (await api.post(endpoints.recordingStartV2, {
-		videoRecordingId: params.videoRecordingId,
-		frameRate: 30,
-		outputMode: "COMPOSED",
-		resolution: params.resolution,
-		type: params.type,
-		hasAudio: params.hasAudio ?? false
-	})).data;
-}
-async function stopRecording(videoRecordingId) {
-	return (await api.post(endpoints.recordingStopV2, { videoRecordingId })).data;
-}
-async function uploadDeepsightVideo(encryptedVideo, token) {
-	try {
-		return (await api.post(endpoints.deepsightVideoImport, {
-			video: encryptedVideo,
-			type: "selfie"
-		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
-	} catch {
-		return "";
-	}
-}
-
-//#endregion
-//#region src/internal/recordings/streamingEvents.ts
-const streamingEvents = {
-	strSessionDidConnect: "strSessionDidConnect",
-	strSessionDidDisconnect: "strSessionDidDisconnect",
-	strSessionDidFailWithError: "strSessionDidFailWithError",
-	strStreamVideoCaptureStart: "strStreamVideoCaptureStart",
-	strStreamVideoCaptureStop: "strStreamVideoCaptureStop",
-	strStreamPublisherCreated: "strStreamPublisherCreated",
-	strStreamPublisherDestroyed: "strStreamPublisherDestroyed",
-	strStreamPublisherDidFailWithError: "strStreamPublisherDidFailWithError"
-};
-
 //#endregion
 //#region src/internal/camera/backCameraStream.ts
 const BACK_CAMERA_KEYWORDS = [
@@ -333,4 +232,4 @@ async function getBackCameraStream(deviceId) {
 }
 
 //#endregion
-export { stopRecording as a, requestPermission as c, startRecording as i, getDeviceClass as l, streamingEvents as n, uploadDeepsightVideo as o, createRecordingSession as r, checkPermission as s, getBackCameraStream as t, getBrowser as u };
+export { getBackCameraStream as t };

package/dist/curp-validation.d.ts

@@ -1,5 +1,6 @@
-import { t as Manager } from "./Manager-DM1NlCX4.js";
-import { r as FlowModuleConfig } from "./types-c0XgGLsM.js";
+import { t as Manager } from "./Manager-C647XkuZ.js";
+import "./types-B3jgq_IJ.js";
+import { r as FlowModuleConfig } from "./types-Skrj9_8y.js";
 
 //#region src/modules/curp-validation/types.d.ts
 type CurpValidationConfig = FlowModuleConfig['CURP_VALIDATION'] & {

package/dist/curp-validation.esm.js

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, r as eventScreenNames, u as screenOpened } from "./events-h8K9H3OM.esm.js";
-import { D as createManager } from "./src-t0pt3B2r.esm.js";
-import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-DXp63GM6.esm.js";
-import { t as api } from "./api-DlSxxyGw.esm.js";
+import { n as eventModuleNames, r as eventScreenNames, u as screenOpened } from "./events-DuBPhaxY.esm.js";
+import { D as createManager } from "./src-Bjg2C1oP.esm.js";
+import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BK1EjE1H.esm.js";
+import { t as api } from "./api-J0YE3G-C.esm.js";
 
 //#region src/modules/curp-validation/curpValidationUtils.ts
 const CURP_PATTERN = /^([A-Z][AEIOUX][A-Z]{2}\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])[HMX](?:AS|B[CS]|C[CLMSH]|D[FG]|G[TR]|HG|JC|M[CNS]|N[ETL]|OC|PL|Q[TR]|S[PLR]|T[CSL]|VZ|YN|ZS)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d])(\d)$/;

package/dist/{deepsightLoader-UBRWJ3MQ.esm.js → deepsightLoader-nGQDTgVU.esm.js}

@@ -1,7 +1,7 @@
-import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-t0pt3B2r.esm.js";
-import { t as createDeepsightService } from "./deepsightService-Bn05rSAa.esm.js";
-import "./api-DlSxxyGw.esm.js";
-import "./stats-GJMiTm5k.esm.js";
+import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-Bjg2C1oP.esm.js";
+import { t as createDeepsightService } from "./deepsightService-CpmpXOnj.esm.js";
+import "./api-J0YE3G-C.esm.js";
+import "./stats-Baxc8J0w.esm.js";
 
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";

package/dist/{deepsightService-Bn05rSAa.esm.js → deepsightService-CpmpXOnj.esm.js}

@@ -1,6 +1,6 @@
-import { E as stopCameraStream, S as IncodeCanvas, T as requestCameraAccess, j as getUserAgent, k as getDeviceInfo, x as createHiddenVideoElement } from "./src-t0pt3B2r.esm.js";
-import { t as api } from "./api-DlSxxyGw.esm.js";
-import { t as addDeviceStats } from "./stats-GJMiTm5k.esm.js";
+import { E as stopCameraStream, S as IncodeCanvas, T as requestCameraAccess, j as getUserAgent, k as getDeviceInfo, x as createHiddenVideoElement } from "./src-Bjg2C1oP.esm.js";
+import { t as api } from "./api-J0YE3G-C.esm.js";
+import { t as addDeviceStats } from "./stats-Baxc8J0w.esm.js";
 
 //#region src/internal/device/browserSimulation.ts
 const AUTOMATION_MARKERS = {

package/dist/{deepsightService-Un1ZwAHH.d.ts → deepsightService-p7oLftiG.d.ts}

@@ -1,4 +1,4 @@
-import { r as CameraStream } from "./types-ee3LkWku.js";
+import { i as CameraStream } from "./types-B3jgq_IJ.js";
 
 //#region ../infra/src/media/canvas.d.ts
 /**

package/dist/document-upload.d.ts

@@ -0,0 +1,329 @@
+import { t as Manager } from "./Manager-C647XkuZ.js";
+import { n as DocumentUploadContext, r as DocumentUploadInput, t as DocumentUploadConfig } from "./types-B3jgq_IJ.js";
+import * as xstate212 from "xstate";
+
+//#region src/modules/document-upload/documentUploadStateMachine.d.ts
+declare const documentUploadMachine: xstate212.StateMachine<DocumentUploadContext, {
+  type: "START";
+} | {
+  type: "CAPTURE";
+  imageBase64: string;
+} | {
+  type: "UPLOAD_PROGRESS";
+  progress: number;
+} | {
+  type: "RETRY";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: xstate212.ActorRefFromLogic<xstate212.PromiseActorLogic<MediaStream, void, xstate212.EventObject>> | xstate212.ActorRefFromLogic<xstate212.PromiseActorLogic<void, {
+    imageBase64: string;
+    documentType: string;
+    onProgress: (progress: number) => void;
+  }, xstate212.EventObject>> | undefined;
+}, xstate212.Values<{
+  initCamera: {
+    src: "initCamera";
+    logic: xstate212.PromiseActorLogic<MediaStream, void, xstate212.EventObject>;
+    id: string | undefined;
+  };
+  uploadDocument: {
+    src: "uploadDocument";
+    logic: xstate212.PromiseActorLogic<void, {
+      imageBase64: string;
+      documentType: string;
+      onProgress: (progress: number) => void;
+    }, xstate212.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate212.Values<{
+  setError: {
+    type: "setError";
+    params: xstate212.NonReducibleUnknown;
+  };
+  setStream: {
+    type: "setStream";
+    params: xstate212.NonReducibleUnknown;
+  };
+  setImageAndClearError: {
+    type: "setImageAndClearError";
+    params: xstate212.NonReducibleUnknown;
+  };
+  setProgress: {
+    type: "setProgress";
+    params: xstate212.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate212.NonReducibleUnknown;
+  };
+  stopStream: {
+    type: "stopStream";
+    params: xstate212.NonReducibleUnknown;
+  };
+}>, never, never, "error" | "idle" | "finished" | "initCamera" | "capturing" | "closed" | "uploading", string, DocumentUploadInput, xstate212.NonReducibleUnknown, xstate212.EventObject, xstate212.MetaObject, {
+  readonly id: "documentUpload";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "initCamera" | "uploadDocument">(logic: TSrc, ...[options]: ({
+        src: "initCamera";
+        logic: xstate212.PromiseActorLogic<MediaStream, void, xstate212.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "initCamera";
+        logic: xstate212.PromiseActorLogic<MediaStream, void, xstate212.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate212.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate212.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate212.RequiredActorOptions<T>]: unknown }) | undefined], xstate212.IsNotNever<xstate212.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "uploadDocument";
+        logic: xstate212.PromiseActorLogic<void, {
+          imageBase64: string;
+          documentType: string;
+          onProgress: (progress: number) => void;
+        }, xstate212.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "uploadDocument";
+        logic: xstate212.PromiseActorLogic<void, {
+          imageBase64: string;
+          documentType: string;
+          onProgress: (progress: number) => void;
+        }, xstate212.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate212.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate212.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate212.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate212.IsNotNever<xstate212.RequiredActorOptions<T_1>>> : never : never : never)): xstate212.ActorRefFromLogic<xstate212.GetConcreteByKey<xstate212.Values<{
+        initCamera: {
+          src: "initCamera";
+          logic: xstate212.PromiseActorLogic<MediaStream, void, xstate212.EventObject>;
+          id: string | undefined;
+        };
+        uploadDocument: {
+          src: "uploadDocument";
+          logic: xstate212.PromiseActorLogic<void, {
+            imageBase64: string;
+            documentType: string;
+            onProgress: (progress: number) => void;
+          }, xstate212.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate212.AnyActorLogic>(src: TLogic, ...[options]: xstate212.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate212.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate212.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate212.IsNotNever<xstate212.RequiredLogicInput<TLogic>>>): xstate212.ActorRefFromLogic<TLogic>;
+    };
+    input: DocumentUploadInput;
+    self: xstate212.ActorRef<xstate212.MachineSnapshot<DocumentUploadContext, {
+      type: "START";
+    } | {
+      type: "CAPTURE";
+      imageBase64: string;
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, Record<string, xstate212.AnyActorRef | undefined>, xstate212.StateValue, string, unknown, any, any>, {
+      type: "START";
+    } | {
+      type: "CAPTURE";
+      imageBase64: string;
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, xstate212.AnyEventObject>;
+  }) => {
+    config: DocumentUploadConfig;
+    stream: undefined;
+    imageBase64: undefined;
+    progress: number;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly START: {
+          readonly target: "initCamera";
+        };
+      };
+    };
+    readonly initCamera: {
+      readonly invoke: {
+        readonly id: "initCamera";
+        readonly src: "initCamera";
+        readonly input: undefined;
+        readonly onDone: {
+          readonly target: "capturing";
+          readonly actions: "setStream";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+      readonly on: {
+        readonly CLOSE: {
+          readonly target: "closed";
+        };
+      };
+    };
+    readonly capturing: {
+      readonly on: {
+        readonly CAPTURE: {
+          readonly target: "uploading";
+          readonly actions: "setImageAndClearError";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly uploading: {
+      readonly invoke: {
+        readonly id: "uploadDocument";
+        readonly src: "uploadDocument";
+        readonly input: ({
+          context,
+          self
+        }: {
+          context: DocumentUploadContext;
+          event: {
+            type: "START";
+          } | {
+            type: "CAPTURE";
+            imageBase64: string;
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          };
+          self: xstate212.ActorRef<xstate212.MachineSnapshot<DocumentUploadContext, {
+            type: "START";
+          } | {
+            type: "CAPTURE";
+            imageBase64: string;
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate212.AnyActorRef>, xstate212.StateValue, string, unknown, any, any>, {
+            type: "START";
+          } | {
+            type: "CAPTURE";
+            imageBase64: string;
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, xstate212.AnyEventObject>;
+        }) => {
+          imageBase64: string;
+          documentType: string;
+          onProgress: (progress: number) => void;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+          readonly actions: "stopStream";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: readonly ["setError", "stopStream"];
+        };
+      };
+      readonly on: {
+        readonly UPLOAD_PROGRESS: {
+          readonly actions: "setProgress";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "initCamera";
+          readonly actions: "clearError";
+        };
+        readonly CLOSE: {
+          readonly target: "closed";
+          readonly actions: "stopStream";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/document-upload/documentUploadActor.d.ts
+type CreateDocumentUploadActorOptions = {
+  config: DocumentUploadConfig;
+};
+//#endregion
+//#region src/modules/document-upload/documentUploadManager.d.ts
+type DocumentUploadInitializingState = {
+  status: 'initializing';
+};
+type DocumentUploadCapturingState = {
+  status: 'capturing';
+  stream: MediaStream;
+};
+type DocumentUploadUploadingState = {
+  status: 'uploading';
+  progress: number;
+};
+type DocumentUploadErrorState = {
+  status: 'error';
+  error: string;
+};
+type DocumentUploadFinishedState = {
+  status: 'finished';
+};
+type DocumentUploadClosedState = {
+  status: 'closed';
+};
+type DocumentUploadState = DocumentUploadInitializingState | DocumentUploadCapturingState | DocumentUploadUploadingState | DocumentUploadErrorState | DocumentUploadFinishedState | DocumentUploadClosedState;
+declare function createDocumentUploadManager(options: CreateDocumentUploadActorOptions): Manager<DocumentUploadState> & {
+  load(): void;
+  capture(imageBase64: string): void;
+  retry(): void;
+  close(): void;
+};
+type DocumentUploadManager = ReturnType<typeof createDocumentUploadManager>;
+//#endregion
+export { type DocumentUploadConfig, type DocumentUploadManager, type DocumentUploadState, createDocumentUploadManager, documentUploadMachine };