@incodetech/core 0.0.0-dev-20260409-a38d5e8 → 0.0.0-dev-20260409-09dfd52

package/dist/documentCaptureStateMachine-ByYOCKz5.esm.js

@@ -0,0 +1,403 @@
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
+import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { i as stopCameraStream } from "./camera-DpPQS_-5.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-D9g2wyil.esm.js";
+
+//#region src/modules/document-capture/types.ts
+const PROCESSING_TYPE_MAP = {
+	processV5CLogbook: "v5cMultiPageLogbook",
+	processCirculationCard: "circulationCard",
+	processFinanceSettlement: "financeSettlement",
+	processCarInvoice: "carInvoice",
+	asyncProcessCarInvoice: "carInvoice",
+	asyncProcessCirculationCard: "circulationCard",
+	capture: "addressStatement"
+};
+const MULTI_PAGE_TYPES = [
+	"v5cMultiPageLogbook",
+	"circulationCard",
+	"financeSettlement"
+];
+const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const DEFAULT_CAPTURE_ATTEMPTS = 3;
+const OTHER_DOCUMENT_TYPES = new Set([
+	"otherDocument1",
+	"otherDocument2",
+	"otherDocument3"
+]);
+const DOCUMENT_CAPTURE_ERROR_CODES = {
+	FILE_TOO_LARGE: "FILE_TOO_LARGE",
+	UPLOAD_FAILED: "UPLOAD_FAILED"
+};
+const DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES = { UNEXPECTED_ERROR: "UNEXPECTED_ERROR" };
+
+//#endregion
+//#region src/modules/document-capture/documentCaptureUploadService.ts
+function isMultiPageDocumentType(processingType) {
+	return MULTI_PAGE_TYPES.includes(processingType);
+}
+function normalizeProcessingType(processingType) {
+	return PROCESSING_TYPE_MAP[processingType] ?? processingType;
+}
+function buildUrl(baseUrl, type, format) {
+	return `${baseUrl}?type=${encodeURIComponent(type)}&format=${format}`;
+}
+function resolveUploadUrl(processingType, fileFormat) {
+	const format = fileFormat === "application/pdf" ? "pdf" : "image";
+	const resolvedType = normalizeProcessingType(processingType);
+	if (isMultiPageDocumentType(resolvedType)) return buildUrl(endpoints.documentV3, resolvedType, format);
+	if (resolvedType === "carInvoice") return buildUrl(endpoints.cfdi, resolvedType, format);
+	if (OTHER_DOCUMENT_TYPES.has(resolvedType)) return buildUrl(endpoints.addDocument, resolvedType, format);
+	if (resolvedType === "addressStatement" || !resolvedType) return buildUrl(endpoints.addressStatement, resolvedType || "addressStatement", format);
+	return buildUrl(endpoints.addressStatement, processingType, format);
+}
+async function uploadDocumentCapture({ base64Image, processingType, fileFormat, onProgress, signal }) {
+	const url = resolveUploadUrl(processingType, fileFormat);
+	const rawBase64 = base64Image.includes(",") ? base64Image.split(",")[1] : base64Image;
+	const response = await api.post(url, { base64Image: rawBase64 }, {
+		signal,
+		onUploadProgress: onProgress
+	});
+	if (!response.ok) throw new Error(`Document upload failed: ${response.status}`);
+	if (!(response.data.success || response.data.status === "SUCCESS" || response.data.status === "ADD_NEXT_PAGE" || response.data.status === "OPTIONAL_PAGE_CAPTURE")) throw new Error("Document upload rejected by server");
+	return response.data;
+}
+function resolveMultiPageDocumentType(processingType) {
+	const resolvedType = normalizeProcessingType(processingType);
+	return isMultiPageDocumentType(resolvedType) ? resolvedType : null;
+}
+async function finalizeDocument({ processingType, signal }) {
+	const type = resolveMultiPageDocumentType(processingType);
+	if (!type) throw new Error(`finalizeDocument only supports multi-page types (${MULTI_PAGE_TYPES.join(", ")})`);
+	const response = await api.post(endpoints.finalizeDocument, { type }, { signal });
+	if (!response.ok) throw new Error(`Document finalize failed: ${response.status}`);
+	const data = response.data;
+	if (!data) throw new Error("Document finalize rejected by server");
+	if (!(data.success || data.status === "SUCCESS")) {
+		const serverStatus = typeof data.status === "string" ? data.status : "unknown";
+		throw new Error(`Document finalize rejected by server (status: ${serverStatus})`);
+	}
+	return data;
+}
+
+//#endregion
+//#region src/modules/document-capture/documentCaptureStateMachine.ts
+const documentCaptureMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		initCamera: fromPromise(async () => {
+			const { stream } = await getBackCameraStream(void 0);
+			return stream;
+		}),
+		uploadDocument: fromPromise(async ({ input, signal }) => {
+			return uploadDocumentCapture({
+				base64Image: input.capturedDocument.imageBase64,
+				processingType: input.processingType,
+				fileFormat: input.capturedDocument.fileType,
+				onProgress: input.onProgress,
+				signal
+			});
+		}),
+		finalizeDocumentRequest: fromPromise(async ({ input, signal }) => {
+			return finalizeDocument({
+				processingType: input.processingType,
+				signal
+			});
+		})
+	},
+	actions: {
+		setStream: assign(({ event }) => ({ stream: event.output })),
+		setCapturedDocument: assign(({ event }) => {
+			const e = event;
+			return {
+				capturedDocument: {
+					imageBase64: e.imageBase64,
+					file: e.file,
+					fileType: e.fileType
+				},
+				error: void 0
+			};
+		}),
+		setFileTooLargeError: assign({ error: () => DOCUMENT_CAPTURE_ERROR_CODES.FILE_TOO_LARGE }),
+		setProgress: assign(({ event }) => ({ progress: event.progress })),
+		setUploadError: assign({ error: () => DOCUMENT_CAPTURE_ERROR_CODES.UPLOAD_FAILED }),
+		setFinalizeError: assign({ error: () => DOCUMENT_CAPTURE_FINALIZE_ERROR_CODES.UNEXPECTED_ERROR }),
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
+		setCaptureMethodFile: assign({ captureMethod: () => "file" }),
+		setCaptureMethodCamera: assign({ captureMethod: () => "camera" }),
+		setCaptureMethodGallery: assign({ captureMethod: () => "gallery" }),
+		clearCapturedDocument: assign({
+			capturedDocument: () => void 0,
+			captureMethod: () => void 0,
+			progress: () => 0,
+			error: () => void 0
+		}),
+		clearCapturedDocumentGalleryRetake: assign({
+			capturedDocument: () => void 0,
+			progress: () => 0,
+			error: () => void 0
+		}),
+		setNextPageType: assign(({ context, event }) => {
+			const { status } = event.output;
+			if (context.captureMethod === "file" && context.capturedDocument?.fileType === "application/pdf") return { nextPageType: "none" };
+			return { nextPageType: status === "ADD_NEXT_PAGE" ? "required" : status === "OPTIONAL_PAGE_CAPTURE" ? "optional" : "none" };
+		}),
+		clearForNextPage: assign(({ context }) => ({
+			capturedDocument: void 0,
+			progress: 0,
+			error: void 0,
+			pageNumber: context.pageNumber + 1,
+			nextPageType: "none",
+			captureMethod: void 0
+		})),
+		clearError: assign({ error: () => void 0 }),
+		resetProgress: assign({ progress: () => 0 }),
+		stopStream: assign(({ context }) => {
+			if (context.stream) stopCameraStream(context.stream);
+			return { stream: void 0 };
+		})
+	},
+	guards: {
+		allowSkip: ({ context }) => context.config.allowSkipDocumentCapture && context.pageNumber === 1,
+		fileSizeOk: ({ context, event }) => {
+			return event.file.size <= context.config.maxFileSize;
+		},
+		canRetryCamera: ({ context }) => context.attemptsRemaining > 0 && context.captureMethod === "camera",
+		canRetryFile: ({ context }) => context.attemptsRemaining > 0 && context.captureMethod !== "camera",
+		canRetryNextDocumentCapture: ({ context }) => context.attemptsRemaining > 0 && context.nextPageType === "optional",
+		attemptsExhausted: ({ context }) => context.attemptsRemaining <= 0,
+		isCameraMode: ({ context }) => context.config.captureMode === "camera",
+		isCaptureMethodCamera: ({ context }) => context.captureMethod === "camera",
+		isCaptureMethodGallery: ({ context }) => context.captureMethod === "gallery",
+		isCaptureMethodFile: ({ context }) => context.captureMethod === "file",
+		isNextPageOptional: ({ context }) => context.nextPageType === "optional",
+		isNextPageRequired: ({ context }) => context.nextPageType === "required",
+		canFinalizeOptionalPages: ({ context }) => context.nextPageType === "optional" && resolveMultiPageDocumentType(context.config.processingType) !== null,
+		fileSizeOkForGallery: ({ context, event }) => {
+			return event.file.size <= context.config.maxFileSize && context.captureMethod === "gallery";
+		},
+		fileSizeOkForNonGallery: ({ context, event }) => {
+			return event.file.size <= context.config.maxFileSize && context.captureMethod !== "gallery";
+		}
+	}
+}).createMachine({
+	id: "documentCapture",
+	initial: "tutorial",
+	context: ({ input }) => {
+		const { processingType = "addressStatement", captureMode = "camera", allowSkipDocumentCapture, disableSkipPoa, captureAttempts = DEFAULT_CAPTURE_ATTEMPTS, sendBase64 = false, maxFileSize = DEFAULT_MAX_FILE_SIZE, title, text, step2Title, step2Text } = input.config;
+		return {
+			config: {
+				processingType,
+				captureMode,
+				allowSkipDocumentCapture: allowSkipDocumentCapture ?? (disableSkipPoa != null ? !disableSkipPoa : false),
+				captureAttempts,
+				sendBase64,
+				maxFileSize,
+				title,
+				text,
+				step2Title,
+				step2Text
+			},
+			stream: void 0,
+			capturedDocument: void 0,
+			captureMethod: void 0,
+			progress: 0,
+			error: void 0,
+			attemptsRemaining: captureAttempts,
+			pageNumber: 1,
+			nextPageType: "none"
+		};
+	},
+	states: {
+		tutorial: { on: {
+			CAPTURE: [{
+				target: "initCamera",
+				guard: "isCameraMode"
+			}, { target: "capturing" }],
+			FILE_SELECTED: [{
+				target: "preview",
+				guard: "fileSizeOk",
+				actions: ["setCapturedDocument", "setCaptureMethodFile"]
+			}, {
+				target: "tutorial",
+				actions: "setFileTooLargeError"
+			}],
+			SKIP: {
+				target: "finished",
+				guard: "allowSkip"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		initCamera: {
+			invoke: {
+				id: "initCamera",
+				src: "initCamera",
+				input: void 0,
+				onDone: {
+					target: "capturing",
+					actions: "setStream"
+				},
+				onError: {
+					target: "failure",
+					actions: "setUploadError"
+				}
+			},
+			on: { CLOSE: { target: "closed" } }
+		},
+		capturing: { on: {
+			FILE_SELECTED: [
+				{
+					target: "preview",
+					guard: "fileSizeOkForGallery",
+					actions: "setCapturedDocument"
+				},
+				{
+					target: "preview",
+					guard: "fileSizeOkForNonGallery",
+					actions: ["setCapturedDocument", "setCaptureMethodCamera"]
+				},
+				{
+					target: "capturing",
+					actions: "setFileTooLargeError"
+				}
+			],
+			CLOSE: {
+				target: "closed",
+				actions: "stopStream"
+			}
+		} },
+		preview: { on: {
+			ACCEPT: {
+				target: "uploading",
+				actions: "resetProgress"
+			},
+			RETAKE: [
+				{
+					target: "tutorial",
+					guard: "isCaptureMethodFile",
+					actions: "clearCapturedDocument"
+				},
+				{
+					target: "capturing",
+					guard: "isCaptureMethodGallery",
+					actions: "clearCapturedDocumentGalleryRetake"
+				},
+				{
+					target: "capturing",
+					actions: "clearCapturedDocument"
+				}
+			],
+			CLOSE: {
+				target: "closed",
+				actions: "stopStream"
+			}
+		} },
+		uploading: {
+			invoke: {
+				id: "uploadDocument",
+				src: "uploadDocument",
+				input: ({ context, self }) => {
+					if (!context.capturedDocument) throw new Error("No captured document to upload");
+					return {
+						capturedDocument: context.capturedDocument,
+						processingType: context.config.processingType,
+						onProgress: (progress) => {
+							self.send({
+								type: "UPLOAD_PROGRESS",
+								progress
+							});
+						}
+					};
+				},
+				onDone: {
+					target: "success",
+					actions: ["setNextPageType", "stopStream"]
+				},
+				onError: {
+					target: "failure",
+					actions: [
+						"setUploadError",
+						"decrementAttemptsRemaining",
+						"stopStream"
+					]
+				}
+			},
+			on: { UPLOAD_PROGRESS: { actions: "setProgress" } }
+		},
+		success: { on: {
+			CONTINUE: [
+				{
+					target: "nextPage",
+					guard: "isNextPageOptional"
+				},
+				{
+					target: "nextPage",
+					guard: "isNextPageRequired"
+				},
+				{ target: "finished" }
+			],
+			CLOSE: { target: "closed" }
+		} },
+		nextPage: { on: {
+			NEXT_PAGE_CAMERA: {
+				target: "initCamera",
+				actions: ["clearForNextPage", "setCaptureMethodCamera"]
+			},
+			NEXT_PAGE_PHOTO_LIBRARY: {
+				target: "capturing",
+				actions: ["clearForNextPage", "setCaptureMethodGallery"]
+			},
+			ALL_PAGES_CAPTURED: [{
+				target: "finalizing",
+				guard: "canFinalizeOptionalPages"
+			}, { target: "finished" }],
+			CLOSE: { target: "closed" }
+		} },
+		finalizing: { invoke: {
+			id: "finalizeDocument",
+			src: "finalizeDocumentRequest",
+			input: ({ context }) => ({ processingType: context.config.processingType }),
+			onDone: { target: "finished" },
+			onError: {
+				target: "failure",
+				actions: ["setFinalizeError", "decrementAttemptsRemaining"]
+			}
+		} },
+		failure: {
+			on: {
+				RETRY: [
+					{
+						target: "nextPage",
+						guard: "canRetryNextDocumentCapture",
+						actions: ["clearError", "clearCapturedDocument"]
+					},
+					{
+						target: "initCamera",
+						guard: "canRetryCamera",
+						actions: ["clearError", "clearCapturedDocument"]
+					},
+					{
+						target: "tutorial",
+						guard: "canRetryFile",
+						actions: ["clearError", "clearCapturedDocument"]
+					}
+				],
+				CLOSE: { target: "closed" }
+			},
+			after: { 3e3: {
+				target: "finished",
+				guard: "attemptsExhausted"
+			} }
+		},
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+export { DOCUMENT_CAPTURE_ERROR_CODES as n, documentCaptureMachine as t };

package/dist/ekyb.d.ts

@@ -1,6 +1,6 @@
-import { t as Manager } from "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
-import { n as AddressSuggestion, r as FieldDef, t as DisplayErrorsResult } from "./displayErrors-BZLX7idb.js";
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
+import { n as AddressSuggestion, r as FieldDef, t as DisplayErrorsResult } from "./displayErrors-xrg0ejaS.js";
 
 //#region src/modules/ekyb/types.d.ts
 type UboEntry = {