@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/documentCaptureManager-DszmcU-l.esm.js

@@ -0,0 +1,296 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-D2jBwwVb.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 resolveMode(config) {
+	if (config.onlyCapture) return "captureOnly";
+	if (config.onlyUpload) return "uploadOnly";
+	return "both";
+}
+/**
+* Maps a document-capture state-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: POA / Document Capture Figma file
+* (`https://www.figma.com/design/cbFXiChmJ8cWQDHwVghBqJ/Document-Capture---Latest-Design?node-id=5140-36443`).
+*
+* The family is `documentCapture.*` with these sub-families:
+*
+* - `documentCapture.tutorial.*` — tutorial + method-selection surfaces
+*   (`default` / `captureOnly` / `uploadOnly` / `methodSelectionWeb` /
+*   `nativeMethodSelection` / `uploadOnlySelector`), driven by the
+*   resolved mode, the `methodSelectionOpen` flag, and `captureMethod`
+*   (`methodSelectionWeb` is our selector; picking "upload" flips it to
+*   `nativeMethodSelection` for the native OS file picker step).
+* - `documentCapture.capture.*` + `documentCapture.commonIssues.*` — camera
+*   capture path + help overlay.
+* - `documentCapture.upload.*` — file / photo-library selection
+*   (`selectFromFiles` / `selectFromLibrary`), keyed off `captureMethod`.
+* - `documentCapture.confirmImage.*` — review/analyze/success for
+*   camera+gallery captures.
+* - `documentCapture.confirmUpload.*` — review/analyze/success for file
+*   uploads.
+* - `documentCapture.nextPage.*` — mandatory / optional next-page prompts.
+* - `documentCapture.errors.*` — recoverable / exhausted error surfaces.
+*
+* The mapper returns Figma-verbatim strings which the adapter emits as-is on
+* `event.screen`. See `docs/patterns/INSTRUMENTATION.md` for the contract.
+*
+* `permissions`/`initCamera`/`finalizing` are intentionally unmapped — the
+* Figma canvas does not define screens for them and falling back to the
+* generic `<module>.<state>` default is the better signal for analytics.
+* `closed` is intentionally unmapped (terminal user-dismissed state — handled
+* by `moduleClosed`). The native-app-only screen (`methodSelectionNative`) and
+* unwired error variants (`errors.noConnection`) are out of scope for the web
+* SDK.
+*/
+function getDocumentCaptureScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	const { context } = snapshot;
+	const mode = resolveMode(context.config);
+	const isFileMethod = context.captureMethod === "file";
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "tutorial":
+			if (context.methodSelectionOpen) {
+				if (mode === "uploadOnly") return "documentCapture.tutorial.uploadOnlySelector";
+				if (mode === "both") return isFileMethod ? "documentCapture.tutorial.nativeMethodSelection" : "documentCapture.tutorial.methodSelectionWeb";
+				return "documentCapture.tutorial.captureOnly";
+			}
+			if (mode === "captureOnly") return "documentCapture.tutorial.captureOnly";
+			if (mode === "uploadOnly") return "documentCapture.tutorial.uploadOnly";
+			return "documentCapture.tutorial.default";
+		case "capturing":
+			if (context.helpOpen) return "documentCapture.commonIssues.default";
+			if (context.captureMethod === "gallery") return "documentCapture.upload.selectFromLibrary";
+			if (context.captureMethod === "file") return "documentCapture.upload.selectFromFiles";
+			return "documentCapture.capture.default";
+		case "preview": return isFileMethod ? "documentCapture.confirmUpload.reviewFile" : "documentCapture.confirmImage.reviewPhoto";
+		case "uploading": return isFileMethod ? "documentCapture.confirmUpload.analyzing" : "documentCapture.confirmImage.analyzing";
+		case "success":
+		case "finished": return isFileMethod ? "documentCapture.confirmUpload.success" : "documentCapture.confirmImage.success";
+		case "failure": return (context.attemptsRemaining ?? 0) > 0 ? "documentCapture.errors.genericError" : "documentCapture.errors.genericErrorExhausted";
+		case "nextPage": {
+			const nextPageType = context.nextPageType;
+			if (nextPageType === "required") return "documentCapture.nextPage.mandatory";
+			if (nextPageType === "optional") return "documentCapture.nextPage.optional";
+			return;
+		}
+		default: return;
+	}
+}
+function getPermissionStatus(snapshot) {
+	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
+	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
+	if (snapshot.matches({ permissions: "denied" })) return "denied";
+	if (snapshot.matches({ permissions: "idle" })) return "checking";
+	return "idle";
+}
+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,
+			onlyCapture: context.config.onlyCapture,
+			onlyUpload: context.config.onlyUpload,
+			methodSelectionOpen: context.methodSelectionOpen,
+			onlyPdf: context.config.onlyPdf,
+			error: context.error,
+			pageNumber: context.pageNumber
+		};
+	}
+	if (typedSnapshot.matches("permissions")) return {
+		status: "permissions",
+		permissionStatus: getPermissionStatus(typedSnapshot)
+	};
+	if (typedSnapshot.matches("initCamera")) return { status: "initializingCamera" };
+	if (typedSnapshot.matches("capturing")) return {
+		status: "capturing",
+		stream: context.stream,
+		onlyCapture: context.config.onlyCapture,
+		onlyUpload: context.config.onlyUpload,
+		captureMethod: context.captureMethod,
+		helpOpen: context.helpOpen,
+		onlyPdf: context.config.onlyPdf,
+		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,
+		onlyCapture: context.config.onlyCapture,
+		onlyUpload: context.config.onlyUpload,
+		onlyPdf: context.config.onlyPdf
+	};
+	if (typedSnapshot.matches("finalizing")) return { status: "finalizing" };
+	return {
+		status: "tutorial",
+		title: void 0,
+		text: void 0,
+		allowSkipDocumentCapture: false,
+		onlyCapture: false,
+		onlyUpload: false,
+		methodSelectionOpen: false,
+		onlyPdf: false,
+		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" });
+		},
+		openMethodSelection() {
+			trackElementClicked?.("openMethodSelection");
+			actor.send({ type: "OPEN_METHOD_SELECTION" });
+		},
+		closeMethodSelection() {
+			trackElementClicked?.("closeMethodSelection");
+			actor.send({ type: "CLOSE_METHOD_SELECTION" });
+		},
+		selectUploadMethod() {
+			trackElementClicked?.("selectUploadMethod");
+			actor.send({ type: "SELECT_UPLOAD_METHOD" });
+		},
+		deselectUploadMethod() {
+			actor.send({ type: "DESELECT_UPLOAD_METHOD" });
+		},
+		openHelp() {
+			trackElementClicked?.("openHelp");
+			actor.send({ type: "OPEN_HELP" });
+		},
+		closeHelp() {
+			trackElementClicked?.("closeHelp");
+			actor.send({ type: "CLOSE_HELP" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		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, {
+			getEventScreenName: getDocumentCaptureScreenName,
+			getErrorPayload: getDocumentCaptureErrorPayload
+		})
+	});
+}
+/**
+* Creates a document-capture manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createDocumentCaptureManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.document, { getErrorPayload: getDocumentCaptureErrorPayload })
+	});
+}
+//#endregion
+export { createDocumentCaptureManagerFromActor as n, createDocumentCaptureManager as t };

package/dist/{documentCaptureStateMachine-BkTvU3yq.esm.js → documentCaptureStateMachine-D2jBwwVb.esm.js}

@@ -1,11 +1,11 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { a as stopCameraStream } from "./camera-CxxXV0VN.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-ChrMTJv-.esm.js";
-import { r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BNOe4Tnu.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { a as stopCameraStream } from "./camera-_2sXMXiF.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
+import { r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KINpmKtI.esm.js";
 //#region src/modules/document-capture/types.ts
 const PROCESSING_TYPE_MAP = {
 	processV5CLogbook: "v5cMultiPageLogbook",
@@ -14,16 +14,19 @@ const PROCESSING_TYPE_MAP = {
 	processCarInvoice: "carInvoice",
 	asyncProcessCarInvoice: "carInvoice",
 	asyncProcessCirculationCard: "circulationCard",
-	capture: "addressStatement"
+	capture: "addressStatement",
+	processW8BenOcr: "w8Ben",
+	processW8BenEOcr: "w8BenE"
 };
 const MULTI_PAGE_TYPES = [
 	"v5cMultiPageLogbook",
 	"circulationCard",
-	"financeSettlement"
+	"financeSettlement",
+	"w8BenE"
 ];
+const V3_SINGLE_PAGE_TYPES = /* @__PURE__ */ new Set(["w8Ben"]);
 const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_CAPTURE_ATTEMPTS = 3;
-const OTHER_DOCUMENT_TYPES = new Set([
+const OTHER_DOCUMENT_TYPES = /* @__PURE__ */ new Set([
 	"otherDocument1",
 	"otherDocument2",
 	"otherDocument3"
@@ -33,7 +36,6 @@ const DOCUMENT_CAPTURE_ERROR_CODES = {
 	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) {
@@ -49,6 +51,7 @@ 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 (V3_SINGLE_PAGE_TYPES.has(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);
@@ -82,7 +85,6 @@ async function finalizeDocument({ processingType, signal }) {
 	}
 	return data;
 }
-
 //#endregion
 //#region src/modules/document-capture/documentCaptureStateMachine.ts
 const documentCaptureMachine = setup({
@@ -139,6 +141,11 @@ const documentCaptureMachine = setup({
 		setCaptureMethodFile: assign({ captureMethod: () => "file" }),
 		setCaptureMethodCamera: assign({ captureMethod: () => "camera" }),
 		setCaptureMethodGallery: assign({ captureMethod: () => "gallery" }),
+		clearCaptureMethod: assign({ captureMethod: () => void 0 }),
+		openMethodSelection: assign({ methodSelectionOpen: () => true }),
+		closeMethodSelection: assign({ methodSelectionOpen: () => false }),
+		openHelp: assign({ helpOpen: () => true }),
+		closeHelp: assign({ helpOpen: () => false }),
 		clearCapturedDocument: assign({
 			capturedDocument: () => void 0,
 			captureMethod: () => void 0,
@@ -178,7 +185,7 @@ const documentCaptureMachine = setup({
 		},
 		canRetry: ({ context }) => context.attemptsRemaining > 0,
 		attemptsExhausted: ({ context }) => context.attemptsRemaining <= 0,
-		isCameraMode: ({ context }) => context.config.captureMode === "camera",
+		allowsCameraCapture: ({ context }) => !context.config.onlyUpload,
 		isCameraPermissionGranted: ({ context, event }) => {
 			const output = event.output;
 			return isReadyForCaptureFromPermission(resolveStoredPermissionResult(output, context.permissionResult), false);
@@ -201,15 +208,17 @@ const documentCaptureMachine = setup({
 	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;
+		const { processingType = "addressStatement", captureMode, allowSkipDocumentCapture, disableSkipPoa, captureAttempts = 3, sendBase64 = false, maxFileSize = DEFAULT_MAX_FILE_SIZE, onlyPdf = false, title, text, step2Title, step2Text } = input.config;
 		return {
 			config: {
 				processingType,
-				captureMode,
+				onlyCapture: captureMode === "camera",
+				onlyUpload: captureMode === "file",
 				allowSkipDocumentCapture: allowSkipDocumentCapture ?? (disableSkipPoa != null ? !disableSkipPoa : false),
 				captureAttempts,
 				sendBase64,
 				maxFileSize,
+				onlyPdf,
 				title,
 				text,
 				step2Title,
@@ -219,6 +228,8 @@ const documentCaptureMachine = setup({
 			permissionResult: void 0,
 			capturedDocument: void 0,
 			captureMethod: void 0,
+			methodSelectionOpen: false,
+			helpOpen: false,
 			progress: 0,
 			error: void 0,
 			attemptsRemaining: captureAttempts,
@@ -228,17 +239,29 @@ const documentCaptureMachine = setup({
 	},
 	states: {
 		tutorial: { on: {
+			OPEN_METHOD_SELECTION: { actions: "openMethodSelection" },
+			CLOSE_METHOD_SELECTION: { actions: ["closeMethodSelection", "clearCaptureMethod"] },
+			SELECT_UPLOAD_METHOD: { actions: "setCaptureMethodFile" },
+			DESELECT_UPLOAD_METHOD: { actions: "clearCaptureMethod" },
 			CAPTURE: [{
 				target: "permissions",
-				guard: "isCameraMode"
-			}, { target: "capturing" }],
+				guard: "allowsCameraCapture",
+				actions: ["closeMethodSelection", "clearCaptureMethod"]
+			}, {
+				target: "capturing",
+				actions: ["closeMethodSelection", "clearCaptureMethod"]
+			}],
 			FILE_SELECTED: [{
 				target: "preview",
 				guard: "fileSizeOk",
-				actions: ["setCapturedDocument", "setCaptureMethodFile"]
+				actions: [
+					"setCapturedDocument",
+					"setCaptureMethodFile",
+					"closeMethodSelection"
+				]
 			}, {
 				target: "tutorial",
-				actions: "setFileTooLargeError"
+				actions: ["setFileTooLargeError", "closeMethodSelection"]
 			}],
 			SKIP: {
 				target: "finished",
@@ -333,16 +356,22 @@ const documentCaptureMachine = setup({
 			on: { CLOSE: { target: "closed" } }
 		},
 		capturing: { on: {
+			OPEN_HELP: { actions: "openHelp" },
+			CLOSE_HELP: { actions: "closeHelp" },
 			FILE_SELECTED: [
 				{
 					target: "preview",
 					guard: "fileSizeOkForGallery",
-					actions: "setCapturedDocument"
+					actions: ["setCapturedDocument", "closeHelp"]
 				},
 				{
 					target: "preview",
 					guard: "fileSizeOkForNonGallery",
-					actions: ["setCapturedDocument", "setCaptureMethodCamera"]
+					actions: [
+						"setCapturedDocument",
+						"setCaptureMethodCamera",
+						"closeHelp"
+					]
 				},
 				{
 					target: "capturing",
@@ -451,28 +480,25 @@ const documentCaptureMachine = setup({
 				actions: ["setFinalizeError", "decrementAttemptsRemaining"]
 			}
 		} },
-		failure: {
-			on: {
-				RETRY: {
-					target: "tutorial",
-					guard: "canRetry",
-					actions: [
-						"clearError",
-						"clearCapturedDocument",
-						"resetPageNumber"
-					]
-				},
-				CLOSE: { target: "closed" }
+		failure: { on: {
+			RETRY: {
+				target: "tutorial",
+				guard: "canRetry",
+				actions: [
+					"clearError",
+					"clearCapturedDocument",
+					"resetPageNumber"
+				]
 			},
-			after: { 3e3: {
+			CONTINUE: {
 				target: "finished",
 				guard: "attemptsExhausted"
-			} }
-		},
+			},
+			CLOSE: { target: "closed" }
+		} },
 		finished: { type: "final" },
 		closed: { type: "final" }
 	}
 });
-
 //#endregion
-export { DOCUMENT_CAPTURE_ERROR_CODES as n, documentCaptureMachine as t };
+export { DOCUMENT_CAPTURE_ERROR_CODES as n, documentCaptureMachine as t };

package/dist/dynamic-forms.d.ts

@@ -1,5 +1,3 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { c as DynamicFormsValidationErrors, d as Question, f as Screen, l as DynamicFormsConfig, n as DynamicFormsState, o as DynamicFormsResult, r as createDynamicFormsManager, s as dynamicFormsMachine, t as DynamicFormsManager, u as InputType } from "./dynamicFormsManager-CKZkE7Wo.js";
+import { i as Screen, n as InputType, r as Question, t as DynamicFormsConfig } from "./types-BSBzhHRH.js";
+import { c as DynamicFormsValidationErrors, n as DynamicFormsState, o as DynamicFormsResult, r as createDynamicFormsManager, s as dynamicFormsMachine, t as DynamicFormsManager } from "./dynamicFormsManager-fhK0yINk.js";
 export { type DynamicFormsConfig, type DynamicFormsManager, type DynamicFormsResult, type DynamicFormsState, type DynamicFormsValidationErrors, type InputType, type Question, type Screen, createDynamicFormsManager, dynamicFormsMachine };

package/dist/dynamic-forms.esm.js

@@ -1,9 +1,3 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import "./dateUtils-BW6mBV6p.esm.js";
-import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-DJ1HGZff.esm.js";
-import { t as createDynamicFormsManager } from "./dynamicFormsManager-CHXUBNs4.esm.js";
-
-export { createDynamicFormsManager, dynamicFormsMachine };
+import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-D_3oLtOE.esm.js";
+import { t as createDynamicFormsManager } from "./dynamicFormsManager-B-OmpJkU.esm.js";
+export { createDynamicFormsManager, dynamicFormsMachine };

package/dist/{dynamicFormsManager-CHXUBNs4.esm.js → dynamicFormsManager-B-OmpJkU.esm.js}

@@ -1,12 +1,11 @@
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-DJ1HGZff.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-D_3oLtOE.esm.js";
 //#region src/modules/dynamic-forms/dynamicFormsActor.ts
 function createDynamicFormsActor(options) {
 	return createActor(dynamicFormsMachine, { input: { config: options.config } }).start();
 }
-
 //#endregion
 //#region src/modules/dynamic-forms/dynamicFormsManager.ts
 /**
@@ -80,7 +79,9 @@ function mapState(snapshot) {
 		answers: context.answers,
 		answerValidity: context.answerValidity,
 		validationErrors: context.validationErrors,
-		canSubmit: hasNoErrors(context.validationErrors)
+		canSubmit: hasNoErrors(context.validationErrors),
+		prefilledQuestionIds: Object.keys(context.prefilledValues),
+		nonEditableQuestionIds: context.nonEditableQuestionIds
 	};
 	if (typedSnapshot.matches("submitting")) {
 		const currentScreen = context.screens[context.currentScreenIndex];
@@ -91,7 +92,9 @@ function mapState(snapshot) {
 			currentScreen,
 			answers: context.answers,
 			answerValidity: context.answerValidity,
-			validationErrors: context.validationErrors
+			validationErrors: context.validationErrors,
+			prefilledQuestionIds: Object.keys(context.prefilledValues),
+			nonEditableQuestionIds: context.nonEditableQuestionIds
 		};
 	}
 	if (typedSnapshot.matches("success")) return { status: "success" };
@@ -101,13 +104,26 @@ function mapState(snapshot) {
 	};
 	if (typedSnapshot.matches("misconfigured")) return { status: "misconfigured" };
 	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	if (typedSnapshot.matches("attemptsExhausted")) return { status: "attemptsExhausted" };
 	return { status: "idle" };
 }
 function createApi({ actor, trackElementClicked }) {
 	return {
+		/**
+		* Initializes the dynamic forms flow.
+		* Transitions from 'idle' to 'loadingScreens' or 'inputting'.
+		* Must be called before any other method.
+		*/
 		load() {
 			actor.send({ type: "LOAD" });
 		},
+		/**
+		* 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, value) {
 			actor.send({
 				type: "ANSWER_CHANGED",
@@ -115,6 +131,15 @@ function createApi({ actor, trackElementClicked }) {
 				value
 			});
 		},
+		/**
+		* Reports the format validity of a question's current value.
+		* Used for fields with format constraints (PHONE, EMAIL, CPF).
+		* A `false` entry feeds into the `formatViaAnswerValidity` validation rule
+		* and surfaces as a `validationErrors[questionId]` entry once validated.
+		*
+		* @param questionId - The question ID from the screen definition
+		* @param isValid - Whether the current value passes format validation
+		*/
 		setAnswerValidity(questionId, isValid) {
 			actor.send({
 				type: "ANSWER_VALIDITY_CHANGED",
@@ -122,16 +147,31 @@ function createApi({ actor, trackElementClicked }) {
 				isValid
 			});
 		},
+		/**
+		* Triggers validation for a single field (e.g., on blur).
+		* Populates or clears `validationErrors[questionId]` accordingly.
+		*
+		* @param questionId - The question ID from the screen definition
+		*/
 		validateField(questionId) {
 			actor.send({
 				type: "VALIDATE_FIELD",
 				questionId
 			});
 		},
+		/**
+		* 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() {
 			trackElementClicked?.("submit");
 			actor.send({ type: "SUBMIT" });
 		},
+		/**
+		* Dismisses the module from 'misconfigured' state.
+		* Fix the config (provide `screens` or `flowId`) rather than calling `reset()`.
+		*/
 		close() {
 			trackElementClicked?.("close");
 			actor.send({ type: "CLOSE" });
@@ -162,6 +202,5 @@ function createDynamicFormsManagerFromActor(actor) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.forms, { getEventScreenName: getDynamicFormsScreenName })
 	});
 }
-
 //#endregion
-export { createDynamicFormsManagerFromActor as n, createDynamicFormsManager as t };
+export { createDynamicFormsManagerFromActor as n, createDynamicFormsManager as t };