@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/documentCaptureStateMachine-BqzTDy9k.esm.js

@@ -0,0 +1,394 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { i as stopCameraStream } from "./camera-PA2Ljri3.esm.js";
+import { t as getBackCameraStream } from "./backCameraStream-DMdMeGk2.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
+		}),
+		resetPageNumber: assign({ pageNumber: () => 1 }),
+		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;
+		},
+		canRetry: ({ context }) => context.attemptsRemaining > 0,
+		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: "tutorial",
+					guard: "canRetry",
+					actions: [
+						"clearError",
+						"clearCapturedDocument",
+						"resetPageNumber"
+					]
+				},
+				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/dynamic-forms.d.ts

@@ -0,0 +1,178 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+
+//#region src/modules/dynamic-forms/types.d.ts
+
+/**
+ * Input types supported by dynamic form questions.
+ * `inputType` on `Question` is optional so unknown future API values degrade
+ * gracefully to the text fallback rather than requiring this union to be widened.
+ */
+type InputType = 'TEXT' | 'DATE' | 'COUNTRY' | 'NATIONALITY' | 'NUMBER' | 'EMAIL' | 'PHONE' | 'CPF' | 'NAME' | 'YESNO' | 'SELECT' | 'MULTISELECT';
+/**
+ * A single question within a dynamic form screen.
+ */
+type Question = {
+  questionId: string;
+  /** Display label shown to the user */
+  question: string;
+  inputType?: InputType;
+  /** Fallback type used when `inputType` is absent */
+  overrides?: InputType;
+  isPredefined?: boolean;
+  isOptional?: boolean;
+  options?: string[];
+};
+/**
+ * A single screen within the dynamic form flow.
+ */
+type Screen = {
+  title?: string;
+  hideTitle?: boolean;
+  questions: Question[];
+};
+/**
+ * Configuration for the dynamic forms module.
+ * Provide either `screens` (pre-loaded) or `flowId` (fetched from API).
+ */
+type DynamicFormsConfig = {
+  /** Flow ID used to fetch screens from the API when `screens` is not provided */
+  flowId?: string;
+  /** Pre-loaded screens — skips the API fetch when provided */
+  screens?: Screen[];
+};
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsStateMachine.d.ts
+/** Whether the form completed normally or was skipped due to a screen-loading failure. */
+type DynamicFormsResult = 'completed' | 'skipped';
+declare const dynamicFormsMachine: any;
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsActor.d.ts
+type CreateDynamicFormsActorOptions = {
+  config: DynamicFormsConfig;
+};
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsManager.d.ts
+/** Dynamic forms manager is in initial state, waiting for `load()` */
+type DynamicFormsIdleState = {
+  status: 'idle';
+};
+/** Fetching screen configuration from the backend */
+type DynamicFormsLoadingState = {
+  status: 'loadingScreens';
+};
+/**
+ * Ready for user input on the current screen.
+ * @property currentScreen - The screen definition to render
+ * @property screenIndex - 0-based index of the current screen
+ * @property totalScreens - Total number of screens in the form
+ * @property answers - Current answer values keyed by questionId
+ * @property answerValidity - Per-question format validity reported via `setAnswerValidity` (phone, email, CPF, etc.)
+ * @property canSubmit - True when all required questions have non-empty answers AND no validity flag is false
+ */
+type DynamicFormsInputtingState = {
+  status: 'inputting';
+  currentScreen: Screen;
+  screenIndex: number;
+  totalScreens: number;
+  answers: Record<string, string>;
+  answerValidity: Record<string, boolean>;
+  canSubmit: boolean;
+};
+/**
+ * Submitting the current screen's answers to the backend.
+ * The screen data is preserved so the UI can keep the form visible (with
+ * disabled fields and a button spinner) while the request is in-flight.
+ * @property screenIndex - Index of the screen being submitted
+ * @property totalScreens - Total number of screens in the form
+ * @property currentScreen - The screen whose answers are being submitted
+ * @property answers - Frozen answer values at submission time
+ * @property answerValidity - Frozen validity flags at submission time
+ */
+type DynamicFormsSubmittingState = {
+  status: 'submitting';
+  screenIndex: number;
+  totalScreens: number;
+  currentScreen: Screen;
+  answers: Record<string, string>;
+  answerValidity: Record<string, boolean>;
+};
+/**
+ * All screens submitted — success screen visible for ~3 s before
+ * transitioning to `finished`.
+ */
+type DynamicFormsSuccessState = {
+  status: 'success';
+};
+/**
+ * All screens completed or skipped.
+ * @property result - `'completed'` when all screens were submitted successfully;
+ *   `'skipped'` when screen configuration could not be loaded (fire-and-forget).
+ */
+type DynamicFormsFinishedState = {
+  status: 'finished';
+  result: DynamicFormsResult;
+};
+/**
+ * Neither `screens` nor `flowId` was provided — misconfiguration, not a runtime error.
+ * Call `close()` to dismiss. Fix the config (provide `screens` or `flowId`) instead.
+ */
+type DynamicFormsMisconfiguredState = {
+  status: 'misconfigured';
+};
+/** User dismissed the module */
+type DynamicFormsClosedState = {
+  status: 'closed';
+};
+/**
+ * Union of all possible dynamic forms manager states.
+ */
+type DynamicFormsState = DynamicFormsIdleState | DynamicFormsLoadingState | DynamicFormsInputtingState | DynamicFormsSubmittingState | DynamicFormsSuccessState | DynamicFormsFinishedState | DynamicFormsMisconfiguredState | DynamicFormsClosedState;
+/**
+ * Creates a dynamic forms manager for headless or UI-driven usage.
+ *
+ * @param options - Configuration options
+ * @param options.config - Dynamic forms configuration (flowId or pre-loaded screens)
+ *
+ * @returns Dynamic forms manager with state, API methods, and subscription
+ */
+declare function createDynamicFormsManager(options: CreateDynamicFormsActorOptions): Manager<DynamicFormsState> & {
+  /**
+   * Initializes the dynamic forms flow.
+   * Transitions from 'idle' to 'loadingScreens' or 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the answer value for a single question.
+   * Should be called when state is 'inputting'.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param value - The raw user input value (formatting is stripped in Core before submission)
+   */
+  setAnswer(questionId: string, value: string): void;
+  /**
+   * Reports the format validity of a question's current value.
+   * Used for fields with format constraints (PHONE, EMAIL, CPF).
+   * Core factors this into `canSubmit` — a false entry blocks submission.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param isValid - Whether the current value passes format validation
+   */
+  setAnswerValidity(questionId: string, isValid: boolean): void;
+  /**
+   * Submits the current screen's answers.
+   * Transitions to 'submitting', then advances to the next screen or 'finished'.
+   * Answer submission failures are fire-and-forget and do not block progression.
+   */
+  submit(): void;
+  /**
+   * Dismisses the module from 'misconfigured' state.
+   * Fix the config (provide `screens` or `flowId`) rather than calling `reset()`.
+   */
+  close(): void;
+};
+/** Type representing a dynamic forms manager instance. */
+type DynamicFormsManager = ReturnType<typeof createDynamicFormsManager>;
+//#endregion
+export { type DynamicFormsConfig, type DynamicFormsManager, type DynamicFormsResult, type DynamicFormsState, type InputType, type Question, type Screen, createDynamicFormsManager, dynamicFormsMachine };