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

package/dist/document-capture.esm.js

@@ -0,0 +1,156 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, 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 "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import "./backCameraStream-DMdMeGk2.esm.js";
+import { n as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-BqzTDy9k.esm.js";
+
+//#region src/modules/document-capture/documentCaptureActor.ts
+function createDocumentCaptureActor(options) {
+	return createActor(documentCaptureMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/document-capture/documentCaptureManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("tutorial")) {
+		const isSecondPage = context.pageNumber > 1;
+		return {
+			status: "tutorial",
+			title: isSecondPage ? context.config.step2Title ?? context.config.title : context.config.title,
+			text: isSecondPage ? context.config.step2Text ?? context.config.text : context.config.text,
+			allowSkipDocumentCapture: context.config.allowSkipDocumentCapture && context.pageNumber === 1,
+			captureMode: context.config.captureMode,
+			error: context.error,
+			pageNumber: context.pageNumber
+		};
+	}
+	if (typedSnapshot.matches("initCamera")) return { status: "initializingCamera" };
+	if (typedSnapshot.matches("capturing")) return {
+		status: "capturing",
+		stream: context.stream,
+		captureMode: context.config.captureMode,
+		captureMethod: context.captureMethod,
+		error: context.error,
+		pageNumber: context.pageNumber
+	};
+	if (typedSnapshot.matches("preview")) return {
+		status: "preview",
+		imageBase64: context.capturedDocument?.imageBase64 ?? "",
+		fileType: context.capturedDocument?.fileType ?? "",
+		fileName: context.capturedDocument?.file.name ?? ""
+	};
+	if (typedSnapshot.matches("uploading")) return {
+		status: "uploading",
+		progress: context.progress,
+		imageBase64: context.capturedDocument?.imageBase64 ?? "",
+		fileType: context.capturedDocument?.fileType ?? "",
+		fileName: context.capturedDocument?.file.name ?? ""
+	};
+	if (typedSnapshot.matches("success")) return {
+		status: "success",
+		imageBase64: context.capturedDocument?.imageBase64 ?? "",
+		fileType: context.capturedDocument?.fileType ?? "",
+		fileName: context.capturedDocument?.file.name ?? "",
+		nextPageType: context.nextPageType
+	};
+	if (typedSnapshot.matches("failure")) return {
+		status: "failure",
+		error: context.error ?? DOCUMENT_CAPTURE_ERROR_CODES.UPLOAD_FAILED,
+		attemptsRemaining: context.attemptsRemaining
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	if (typedSnapshot.matches("nextPage")) return {
+		status: "nextPage",
+		imageBase64: context.capturedDocument?.imageBase64 ?? "",
+		fileType: context.capturedDocument?.fileType ?? "",
+		fileName: context.capturedDocument?.file.name ?? "",
+		pageNumber: context.pageNumber,
+		nextPageType: context.nextPageType,
+		captureMode: context.config.captureMode
+	};
+	if (typedSnapshot.matches("finalizing")) return { status: "finalizing" };
+	return {
+		status: "tutorial",
+		title: void 0,
+		text: void 0,
+		allowSkipDocumentCapture: false,
+		captureMode: "file",
+		error: void 0,
+		pageNumber: 1
+	};
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "CAPTURE" });
+		},
+		setFile(file, imageBase64) {
+			actor.send({
+				type: "FILE_SELECTED",
+				file,
+				imageBase64,
+				fileType: file.type
+			});
+		},
+		accept() {
+			trackElementClicked?.("accept");
+			actor.send({ type: "ACCEPT" });
+		},
+		retake() {
+			trackElementClicked?.("retake");
+			actor.send({ type: "RETAKE" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		},
+		captureNextPageFromCamera() {
+			trackElementClicked?.("captureNextPageFromCamera");
+			actor.send({ type: "NEXT_PAGE_CAMERA" });
+		},
+		captureNextPageFromFile() {
+			trackElementClicked?.("captureNextPageFromFile");
+			actor.send({ type: "NEXT_PAGE_PHOTO_LIBRARY" });
+		},
+		finishPageCapture() {
+			trackElementClicked?.("finishPageCapture");
+			actor.send({ type: "ALL_PAGES_CAPTURED" });
+		}
+	};
+}
+function getDocumentCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.error;
+	if (errorCode === void 0) return;
+	return { errorCode };
+}
+function createDocumentCaptureManager(options) {
+	return createManager({
+		actor: createDocumentCaptureActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.document, { getErrorPayload: getDocumentCaptureErrorPayload })
+	});
+}
+
+//#endregion
+export { DOCUMENT_CAPTURE_ERROR_CODES, createDocumentCaptureManager, documentCaptureMachine };

package/dist/document-upload.d.ts

@@ -0,0 +1,331 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import "./camera-DBSxa6ML.js";
+import { n as DocumentUploadContext, r as DocumentUploadInput, t as DocumentUploadConfig } from "./types-CFV9G_7j.js";
+import * as xstate938 from "xstate";
+
+//#region src/modules/document-upload/documentUploadStateMachine.d.ts
+declare const documentUploadMachine: xstate938.StateMachine<DocumentUploadContext, {
+  type: "START";
+} | {
+  type: "CAPTURE";
+  imageBase64: string;
+} | {
+  type: "UPLOAD_PROGRESS";
+  progress: number;
+} | {
+  type: "RETRY";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: xstate938.ActorRefFromLogic<xstate938.PromiseActorLogic<MediaStream, void, xstate938.EventObject>> | xstate938.ActorRefFromLogic<xstate938.PromiseActorLogic<void, {
+    imageBase64: string;
+    documentType: string;
+    onProgress: (progress: number) => void;
+  }, xstate938.EventObject>> | undefined;
+}, xstate938.Values<{
+  uploadDocument: {
+    src: "uploadDocument";
+    logic: xstate938.PromiseActorLogic<void, {
+      imageBase64: string;
+      documentType: string;
+      onProgress: (progress: number) => void;
+    }, xstate938.EventObject>;
+    id: string | undefined;
+  };
+  initCamera: {
+    src: "initCamera";
+    logic: xstate938.PromiseActorLogic<MediaStream, void, xstate938.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate938.Values<{
+  setError: {
+    type: "setError";
+    params: xstate938.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate938.NonReducibleUnknown;
+  };
+  setStream: {
+    type: "setStream";
+    params: xstate938.NonReducibleUnknown;
+  };
+  setProgress: {
+    type: "setProgress";
+    params: xstate938.NonReducibleUnknown;
+  };
+  stopStream: {
+    type: "stopStream";
+    params: xstate938.NonReducibleUnknown;
+  };
+  setImageAndClearError: {
+    type: "setImageAndClearError";
+    params: xstate938.NonReducibleUnknown;
+  };
+}>, never, never, "error" | "idle" | "uploading" | "closed" | "finished" | "initCamera" | "capturing", string, DocumentUploadInput, xstate938.NonReducibleUnknown, xstate938.EventObject, xstate938.MetaObject, {
+  readonly id: "documentUpload";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "uploadDocument" | "initCamera">(logic: TSrc, ...[options]: ({
+        src: "uploadDocument";
+        logic: xstate938.PromiseActorLogic<void, {
+          imageBase64: string;
+          documentType: string;
+          onProgress: (progress: number) => void;
+        }, xstate938.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "uploadDocument";
+        logic: xstate938.PromiseActorLogic<void, {
+          imageBase64: string;
+          documentType: string;
+          onProgress: (progress: number) => void;
+        }, xstate938.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate938.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate938.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate938.RequiredActorOptions<T>]: unknown }) | undefined], xstate938.IsNotNever<xstate938.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "initCamera";
+        logic: xstate938.PromiseActorLogic<MediaStream, void, xstate938.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "initCamera";
+        logic: xstate938.PromiseActorLogic<MediaStream, void, xstate938.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate938.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate938.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate938.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate938.IsNotNever<xstate938.RequiredActorOptions<T_1>>> : never : never : never)): xstate938.ActorRefFromLogic<xstate938.GetConcreteByKey<xstate938.Values<{
+        uploadDocument: {
+          src: "uploadDocument";
+          logic: xstate938.PromiseActorLogic<void, {
+            imageBase64: string;
+            documentType: string;
+            onProgress: (progress: number) => void;
+          }, xstate938.EventObject>;
+          id: string | undefined;
+        };
+        initCamera: {
+          src: "initCamera";
+          logic: xstate938.PromiseActorLogic<MediaStream, void, xstate938.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate938.AnyActorLogic>(src: TLogic, ...[options]: xstate938.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate938.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate938.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate938.IsNotNever<xstate938.RequiredLogicInput<TLogic>>>): xstate938.ActorRefFromLogic<TLogic>;
+    };
+    input: DocumentUploadInput;
+    self: xstate938.ActorRef<xstate938.MachineSnapshot<DocumentUploadContext, {
+      type: "START";
+    } | {
+      type: "CAPTURE";
+      imageBase64: string;
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, Record<string, xstate938.AnyActorRef | undefined>, xstate938.StateValue, string, unknown, any, any>, {
+      type: "START";
+    } | {
+      type: "CAPTURE";
+      imageBase64: string;
+    } | {
+      type: "UPLOAD_PROGRESS";
+      progress: number;
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CLOSE";
+    }, xstate938.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: xstate938.ActorRef<xstate938.MachineSnapshot<DocumentUploadContext, {
+            type: "START";
+          } | {
+            type: "CAPTURE";
+            imageBase64: string;
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, Record<string, xstate938.AnyActorRef>, xstate938.StateValue, string, unknown, any, any>, {
+            type: "START";
+          } | {
+            type: "CAPTURE";
+            imageBase64: string;
+          } | {
+            type: "UPLOAD_PROGRESS";
+            progress: number;
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CLOSE";
+          }, xstate938.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 };

package/dist/document-upload.esm.js

@@ -0,0 +1,203 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import { i as stopCameraStream } from "./camera-PA2Ljri3.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-DMdMeGk2.esm.js";
+
+//#region src/modules/document-upload/documentUploadServices.ts
+async function uploadDocument({ imageBase64, documentType, onProgress, signal }) {
+	const url = `${endpoints.addDocument}?type=${encodeURIComponent(documentType)}`;
+	const response = await api.post(url, { base64Image: imageBase64 }, {
+		signal,
+		onUploadProgress: onProgress
+	});
+	if (!response.ok) throw new Error(`Document upload failed: ${response.status} ${response.statusText}`);
+}
+
+//#endregion
+//#region src/modules/document-upload/documentUploadStateMachine.ts
+const documentUploadMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		initCamera: fromPromise(async () => {
+			const { stream } = await getBackCameraStream(void 0);
+			return stream;
+		}),
+		uploadDocument: fromPromise(async ({ input, signal }) => {
+			return uploadDocument({
+				imageBase64: input.imageBase64,
+				documentType: input.documentType,
+				onProgress: input.onProgress,
+				signal
+			});
+		})
+	},
+	actions: {
+		setStream: assign(({ event }) => ({ stream: event.output })),
+		setImageAndClearError: assign(({ event }) => {
+			return {
+				imageBase64: event.imageBase64,
+				error: void 0
+			};
+		}),
+		setProgress: assign(({ event }) => ({ progress: event.progress })),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		stopStream: assign(({ context }) => {
+			if (context.stream) stopCameraStream(context.stream);
+			return { stream: void 0 };
+		})
+	}
+}).createMachine({
+	id: "documentUpload",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		stream: void 0,
+		imageBase64: void 0,
+		progress: 0,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { START: { target: "initCamera" } } },
+		initCamera: {
+			invoke: {
+				id: "initCamera",
+				src: "initCamera",
+				input: void 0,
+				onDone: {
+					target: "capturing",
+					actions: "setStream"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { CLOSE: { target: "closed" } }
+		},
+		capturing: { on: {
+			CAPTURE: {
+				target: "uploading",
+				actions: "setImageAndClearError"
+			},
+			CLOSE: {
+				target: "closed",
+				actions: "stopStream"
+			}
+		} },
+		uploading: {
+			invoke: {
+				id: "uploadDocument",
+				src: "uploadDocument",
+				input: ({ context, self }) => {
+					const imageBase64 = context.imageBase64;
+					if (!imageBase64) throw new Error("No image to upload");
+					return {
+						imageBase64,
+						documentType: context.config.documentType,
+						onProgress: (progress) => {
+							self.send({
+								type: "UPLOAD_PROGRESS",
+								progress
+							});
+						}
+					};
+				},
+				onDone: {
+					target: "finished",
+					actions: "stopStream"
+				},
+				onError: {
+					target: "error",
+					actions: ["setError", "stopStream"]
+				}
+			},
+			on: { UPLOAD_PROGRESS: { actions: "setProgress" } }
+		},
+		error: { on: {
+			RETRY: {
+				target: "initCamera",
+				actions: "clearError"
+			},
+			CLOSE: {
+				target: "closed",
+				actions: "stopStream"
+			}
+		} },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/document-upload/documentUploadActor.ts
+function createDocumentUploadActor(options) {
+	return createActor(documentUploadMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/document-upload/documentUploadManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle") || typedSnapshot.matches("initCamera")) return { status: "initializing" };
+	if (typedSnapshot.matches("capturing")) {
+		if (!context.stream) return { status: "initializing" };
+		return {
+			status: "capturing",
+			stream: context.stream
+		};
+	}
+	if (typedSnapshot.matches("uploading")) return {
+		status: "uploading",
+		progress: context.progress
+	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Upload failed"
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "initializing" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "START" });
+		},
+		capture(imageBase64) {
+			trackElementClicked?.("capture");
+			actor.send({
+				type: "CAPTURE",
+				imageBase64
+			});
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createDocumentUploadManager(options) {
+	return createManager({
+		actor: createDocumentUploadActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.document)
+	});
+}
+
+//#endregion
+export { createDocumentUploadManager, documentUploadMachine };