@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/id-verification.d.ts

@@ -0,0 +1,190 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import * as xstate522 from "xstate";
+
+//#region src/modules/id-verification/types.d.ts
+type IdVerificationConfig = {
+  /** When true, verify the second captured ID via `/omni/process/second-id`. */
+  isSecondId?: boolean;
+  /**
+   * Queue name forwarded as a query parameter. Always sent (default empty
+   * string) so the request shape matches the legacy `/omni/process/id?queueName=`
+   * call that returns 200 today.
+   */
+  queueName?: string;
+  /**
+   * Workflow engine writes the rank into the module configuration when one
+   * `ID` node represents the second ID. When set to `'SECOND_ID'` the
+   * verification routes to the second-id endpoint even without an explicit
+   * `isSecondId` flag.
+   */
+  idRank?: 'FIRST_ID' | 'SECOND_ID' | 'THIRD_ID';
+};
+type ProcessIdResponse = {
+  isDocumentExpired: boolean;
+};
+//#endregion
+//#region src/modules/id-verification/idVerificationStateMachine.d.ts
+type IdVerificationContext = {
+  config: IdVerificationConfig;
+  isSecondId: boolean;
+};
+type IdVerificationInput = {
+  config: IdVerificationConfig;
+};
+declare const idVerificationMachine: xstate522.StateMachine<IdVerificationContext, {
+  type: "LOAD";
+} | {
+  type: "CONTINUE";
+}, {
+  [x: string]: xstate522.ActorRefFromLogic<xstate522.PromiseActorLogic<ProcessIdResponse, {
+    isSecondId: boolean;
+    queueName: string;
+  }, xstate522.EventObject>> | undefined;
+}, {
+  src: "processId";
+  logic: xstate522.PromiseActorLogic<ProcessIdResponse, {
+    isSecondId: boolean;
+    queueName: string;
+  }, xstate522.EventObject>;
+  id: string | undefined;
+}, never, {
+  type: "isDocumentExpired";
+  params: unknown;
+}, never, "idle" | "processing" | "finished" | "expired", string, IdVerificationInput, xstate522.NonReducibleUnknown, xstate522.EventObject, xstate522.MetaObject, {
+  readonly id: "idVerification";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "processId">(logic: TSrc, ...[options]: {
+        src: "processId";
+        logic: xstate522.PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, xstate522.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "processId";
+        logic: xstate522.PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, xstate522.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate522.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate522.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate522.RequiredActorOptions<T>]: unknown }) | undefined], xstate522.IsNotNever<xstate522.RequiredActorOptions<T>>> : never : never : never): xstate522.ActorRefFromLogic<xstate522.GetConcreteByKey<{
+        src: "processId";
+        logic: xstate522.PromiseActorLogic<ProcessIdResponse, {
+          isSecondId: boolean;
+          queueName: string;
+        }, xstate522.EventObject>;
+        id: string | undefined;
+      }, "src", TSrc>["logic"]>;
+      <TLogic extends xstate522.AnyActorLogic>(src: TLogic, ...[options]: xstate522.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate522.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate522.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate522.IsNotNever<xstate522.RequiredLogicInput<TLogic>>>): xstate522.ActorRefFromLogic<TLogic>;
+    };
+    input: IdVerificationInput;
+    self: xstate522.ActorRef<xstate522.MachineSnapshot<IdVerificationContext, {
+      type: "LOAD";
+    } | {
+      type: "CONTINUE";
+    }, Record<string, xstate522.AnyActorRef | undefined>, xstate522.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "CONTINUE";
+    }, xstate522.AnyEventObject>;
+  }) => {
+    config: IdVerificationConfig;
+    isSecondId: boolean;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: "processing";
+      };
+    };
+    readonly processing: {
+      readonly invoke: {
+        readonly id: "processId";
+        readonly src: "processId";
+        readonly input: ({
+          context
+        }: {
+          context: IdVerificationContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          };
+          self: xstate522.ActorRef<xstate522.MachineSnapshot<IdVerificationContext, {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          }, Record<string, xstate522.AnyActorRef>, xstate522.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "CONTINUE";
+          }, xstate522.AnyEventObject>;
+        }) => {
+          isSecondId: boolean;
+          queueName: string;
+        };
+        readonly onDone: readonly [{
+          readonly target: "expired";
+          readonly guard: "isDocumentExpired";
+        }, {
+          readonly target: "finished";
+        }];
+        readonly onError: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly expired: {
+      readonly on: {
+        readonly CONTINUE: "finished";
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/id-verification/idVerificationActor.d.ts
+type CreateIdVerificationActorOptions = {
+  config: IdVerificationConfig;
+};
+//#endregion
+//#region src/modules/id-verification/idVerificationManager.d.ts
+type IdVerificationIdleState = {
+  status: 'idle';
+};
+type IdVerificationProcessingState = {
+  status: 'processing';
+};
+type IdVerificationExpiredState = {
+  status: 'expired';
+};
+type IdVerificationFinishedState = {
+  status: 'finished';
+};
+type IdVerificationState = IdVerificationIdleState | IdVerificationProcessingState | IdVerificationExpiredState | IdVerificationFinishedState;
+declare function createIdVerificationManager(options: CreateIdVerificationActorOptions): Manager<IdVerificationState> & {
+  load(): void;
+  continue(): void;
+};
+type IdVerificationManager = ReturnType<typeof createIdVerificationManager>;
+//#endregion
+export { type IdVerificationConfig, type IdVerificationManager, type IdVerificationState, createIdVerificationManager, idVerificationMachine };

package/dist/id-verification.esm.js

@@ -0,0 +1,43 @@
+import "./api-CESGtpbH.esm.js";
+import { 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 idVerificationMachine } from "./idVerificationStateMachine-xbw9HP1Z.esm.js";
+
+//#region src/modules/id-verification/idVerificationActor.ts
+function createIdVerificationActor(options) {
+	return createActor(idVerificationMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/id-verification/idVerificationManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("expired")) return { status: "expired" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		}
+	};
+}
+function createIdVerificationManager(options) {
+	return createManager({
+		actor: createIdVerificationActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation("ID_VERIFICATION")
+	});
+}
+
+//#endregion
+export { createIdVerificationManager, idVerificationMachine };

package/dist/id.d.ts

@@ -0,0 +1,24 @@
+import "./warmup-CEcppFiS.js";
+import "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import "./StateMachine-BCQrZJhf.js";
+import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import "./types-BP1m8VRw.js";
+import "./deepsightService-CEVxzehb.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CAD4va6a.js";
+import { $ as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, A as CaptureIdResponse, B as IdCaptureGeometry, C as IdCaptureOnlyMachine, D as createIdCaptureActor, E as IdCaptureActor, F as ID_ERROR_CODES, G as IdCapturedImageData, H as IdCaptureMode, I as IdCaptureConfig, J as IdErrorCode, K as IdDocumentType, L as IdCaptureContext, M as CapturedImage, N as DetectionArea, O as IdCaptureMachine, P as DetectionStatus, Q as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, R as IdCaptureDependencies, S as createIdCaptureOnlyActor, T as CreateIdCaptureActorOptions, U as IdCaptureOnlyConfig, V as IdCaptureInput, W as IdCaptureThresholds, X as RecordingSession, Y as IdFlowStep, Z as UploadIdResponse, _ as uploadIdImage, a as IdCaptureInitResult, at as IdCaptureSettings, b as CreateIdCaptureOnlyActorOptions, c as UploadIdImageParams, d as initializeIdCapture, et as MANUAL_UPLOAD_MAX_RETRIES, f as preloadIdRecordingProvider, g as stopStream, h as stopRecording, it as DetectionOrientation, j as CaptureOnlyResponse, k as idCaptureMachine, l as UploadManualIdFileParams, m as startRecordingSession, n as IdCaptureManager, nt as ManualUploadSide, o as InitializeIdCaptureParams, p as processId, q as IdError, r as IdCaptureState, rt as ManualUploadTab, s as StartRecordingParams, t as createIdCaptureManager, tt as ManualUploadContext, u as ValidationError, v as uploadManualIdFile, w as idCaptureOnlyMachine, x as IdCaptureOnlyActor, y as validateUploadResponse, z as IdCaptureEvent } from "./idCaptureManager-Fyd0eam-.js";
+
+//#region src/modules/id/idCaptureOnlyManager.d.ts
+type IdCaptureOnlyManager = IdCaptureManager;
+declare function createIdCaptureOnlyManagerFromActor(actor: IdCaptureOnlyActor, config: IdCaptureOnlyConfig): IdCaptureOnlyManager;
+/**
+ * Creates a captureOnly ID capture manager.
+ *
+ * Unlike {@link createIdCaptureManager}, the captured ID image(s) are
+ * delivered locally to the integrator's `onCapture` callback instead of
+ * being uploaded to the Incode backend. `onCapture` is required.
+ */
+declare function createIdCaptureOnlyManager(options: CreateIdCaptureOnlyActorOptions): IdCaptureOnlyManager;
+//#endregion
+export { CameraStream, CaptureIdResponse, CaptureOnlyResponse, CapturedImage, type CreateIdCaptureActorOptions, type CreateIdCaptureOnlyActorOptions, DetectionArea, DetectionOrientation, DetectionStatus, ID_ERROR_CODES, type IdCaptureActor, IdCaptureConfig, type IdCaptureContext, IdCaptureDependencies, type IdCaptureEvent, IdCaptureGeometry, IdCaptureInitResult, type IdCaptureInput, type IdCaptureMachine, type IdCaptureManager, IdCaptureMode, type IdCaptureOnlyActor, IdCaptureOnlyConfig, type IdCaptureOnlyMachine, type IdCaptureOnlyManager, IdCaptureSettings, type IdCaptureState, IdCaptureThresholds, IdCapturedImageData, IdDocumentType, IdError, IdErrorCode, IdFlowStep, InitializeIdCaptureParams, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, MANUAL_UPLOAD_MAX_RETRIES, ManualUploadContext, ManualUploadSide, ManualUploadTab, PermissionResult, PermissionStatus, RecordingSession, StartRecordingParams, UploadIdImageParams, UploadIdResponse, UploadManualIdFileParams, ValidationError, createIdCaptureActor, createIdCaptureManager, createIdCaptureOnlyActor, createIdCaptureOnlyManager, createIdCaptureOnlyManagerFromActor, idCaptureMachine, idCaptureOnlyMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, uploadManualIdFile, validateUploadResponse };

package/dist/id.esm.js

@@ -0,0 +1,164 @@
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./session-CGtQJJzB.esm.js";
+import "./IpifyProvider-D7jx52AL.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 BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./deepsightService-O74l4Y__.esm.js";
+import "./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 { a as startRecordingSession, c as uploadIdImage, d as ID_ERROR_CODES, f as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, i as processId, l as uploadManualIdFile, m as MANUAL_UPLOAD_MAX_RETRIES, n as initializeIdCapture, o as stopRecording, p as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, r as preloadIdRecordingProvider, s as stopStream, t as idCaptureMachine, u as validateUploadResponse } from "./idCaptureStateMachine-BK0bPHoc.esm.js";
+import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-ZPkD7Gjk.esm.js";
+import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-rc6kBHo5.esm.js";
+
+//#region src/modules/id/idCaptureOnlyStateMachine.ts
+function buildSubImage(canvas) {
+	if (!canvas) return void 0;
+	canvas.updateBlob();
+	const blobData = canvas.getBlobData();
+	if (!blobData) return void 0;
+	const imageBase64 = canvas.getBase64Image() ?? "";
+	if (!imageBase64) return void 0;
+	return {
+		imageBase64,
+		blob: blobData.blob,
+		url: blobData.url
+	};
+}
+/**
+* Local finalize for the captureOnly flow. Reads the canvases the base
+* machine's `storeCapturedCanvasInProvider` already prepared:
+*   - `originalCanvas` — full unprocessed frame.
+*   - `transformedCanvas` — homography-warped crop produced by the WASM
+*     `transformPerspective`.
+*
+* Deepsight metadata is best-effort; failure does not block delivery.
+*/
+async function finalizeIdCaptureOnly(input, signal) {
+	const originalCanvas = input.canvas;
+	if (!originalCanvas) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
+	const imageData = originalCanvas.getImageData() ?? void 0;
+	let metadata = "";
+	if (input.deepsightService && imageData) try {
+		await input.deepsightService.analyzeFrame(imageData);
+		if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+		metadata = input.deepsightService.getMetadata();
+	} catch (error) {
+		if (error?.name === "AbortError") throw error;
+	}
+	const imageBase64 = originalCanvas.getBase64Image() ?? "";
+	originalCanvas.updateBlob();
+	const blobData = originalCanvas.getBlobData();
+	if (!blobData) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
+	return {
+		imageBase64,
+		blob: blobData.blob,
+		url: blobData.url,
+		metadata,
+		croppedImage: buildSubImage(input.croppedCanvas ?? null)
+	};
+}
+const _idCaptureOnlyMachine = idCaptureMachine.provide({
+	actors: {
+		uploadIdImage: fromPromise(async ({ input, signal }) => {
+			return await finalizeIdCaptureOnly(input, signal);
+		}),
+		processId: fromPromise(async () => ({ isDocumentExpired: false })),
+		startRecording: fromPromise(async () => void 0)
+	},
+	actions: { storeCapturedImage: assign(({ context, event }) => {
+		if (!("output" in event) || !context.currentMode) return { captureOnlyImages: context.captureOnlyImages };
+		const image = event.output;
+		const side = context.currentMode === "back" ? "back" : "front";
+		return { captureOnlyImages: {
+			...context.captureOnlyImages,
+			[side]: image
+		} };
+	}) },
+	guards: {
+		hasUploadValidationError: () => false,
+		shouldContinueToBack: ({ context }) => {
+			if (context.currentMode !== "front" && context.currentMode !== "passport") return false;
+			if (context.config.onlyFront) return false;
+			if (context.config.onlyBack) return false;
+			if (context.config.usSmartCapture) return false;
+			return true;
+		}
+	}
+});
+/**
+* ID capture state machine variant for the captureOnly flow. Shares the full
+* base ID-capture state tree (chooser, tutorial, permissions, capture,
+* front/back finished, processing, finished); only the upload, process, and
+* recording steps are local instead of remote.
+*/
+const idCaptureOnlyMachine = _idCaptureOnlyMachine;
+
+//#endregion
+//#region src/modules/id/idCaptureOnlyActor.ts
+function createIdCaptureOnlyActor(options) {
+	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	return createActor(idCaptureOnlyMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/id/idCaptureOnlyManager.ts
+/**
+* Wraps an ID captureOnly actor with a manager that fires `onCapture` exactly
+* once when the actor reaches the `finished` final state. `complete` fires
+* for both `finished` and `closed` — 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 frontImage = snapshot.context.captureOnlyImages.front;
+		if (!frontImage) return;
+		const response = {
+			frontImage,
+			backImage: snapshot.context.captureOnlyImages.back
+		};
+		invokeOnCaptureCallback(config.onCapture, response, eventModuleNames.id);
+	} });
+	return () => subscription.unsubscribe();
+}
+function createIdCaptureOnlyManagerFromActor(actor, config) {
+	const unsubscribe = attachOnCaptureFiring(actor, config);
+	const manager = createIdCaptureManagerFromActor(actor);
+	return {
+		...manager,
+		stop: () => {
+			unsubscribe();
+			manager.stop();
+		}
+	};
+}
+/**
+* Creates a captureOnly ID capture manager.
+*
+* Unlike {@link createIdCaptureManager}, the captured ID image(s) are
+* delivered locally to the integrator's `onCapture` callback instead of
+* being uploaded to the Incode backend. `onCapture` is required.
+*/
+function createIdCaptureOnlyManager(options) {
+	return createIdCaptureOnlyManagerFromActor(createIdCaptureOnlyActor(options), options.config);
+}
+
+//#endregion
+export { ID_ERROR_CODES, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, MANUAL_UPLOAD_MAX_RETRIES, createIdCaptureActor, createIdCaptureManager, createIdCaptureOnlyActor, createIdCaptureOnlyManager, createIdCaptureOnlyManagerFromActor, idCaptureMachine, idCaptureOnlyMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, uploadManualIdFile, validateUploadResponse };