@incodetech/core 2.0.0 → 2.0.1

package/dist/emailStateMachine-DOf4j58N.esm.js

@@ -0,0 +1,292 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/email/emailServices.ts
+function getEmailServerFailureReason(error, invalidStatus) {
+	if (error.status === invalidStatus) return "invalidEmail";
+	return "serverError";
+}
+async function fetchEmail(signal) {
+	const res = await api.get(endpoints.getEmail, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getEmail} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addEmail(params, signal) {
+	try {
+		return (await api.post(endpoints.email, { email: params.email }, { signal })).data;
+	} catch (error) {
+		throw new Error(getEmailServerFailureReason(error, 400));
+	}
+}
+async function sendEmailOtp(signal) {
+	try {
+		await api.get(`${endpoints.sendSmsOtp}?communicationchannel=EMAIL`, { signal });
+	} catch (error) {
+		throw new Error(getEmailServerFailureReason(error));
+	}
+}
+async function verifyEmailOtp(code, signal) {
+	try {
+		return (await api.get(`${endpoints.compareOtp}?code=${code}&channel=EMAIL`, { signal })).data;
+	} catch (error) {
+		throw new Error(getEmailServerFailureReason(error));
+	}
+}
+
+//#endregion
+//#region src/modules/email/emailStateMachine.ts
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+const RESEND_TIMER_SECONDS = 30;
+const emailMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchEmail: fromPromise(async ({ signal }) => {
+			return fetchEmail(signal);
+		}),
+		submitEmail: fromPromise(async ({ input, signal }) => {
+			return addEmail({ email: input.email }, signal);
+		}),
+		sendOtp: fromPromise(async ({ signal }) => {
+			return sendEmailOtp(signal);
+		}),
+		verifyOtp: fromPromise(async ({ input, signal }) => {
+			return verifyEmailOtp(input.code, signal);
+		}),
+		resendTimer: fromCallback(({ input, sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			let remaining = input.seconds;
+			if (remaining <= 0) return () => {};
+			const interval = timer.setInterval(() => {
+				sendBack({ type: "TICK" });
+				remaining -= 1;
+				if (remaining <= 0) timer.clearInterval(interval);
+			}, 1e3);
+			return () => timer.clearInterval(interval);
+		})
+	},
+	actions: {
+		setPrefilledEmail: assign(({ event }) => {
+			const email = event.output.email;
+			return {
+				prefilledEmail: email,
+				email
+			};
+		}),
+		setEmail: assign(({ event }) => {
+			const e = event;
+			return {
+				email: e.email,
+				isValid: e.isValid,
+				emailError: void 0
+			};
+		}),
+		setEmailError: assign(({ event }) => ({ emailError: getErrorMessage(event.error) })),
+		setError: assign(({ event }) => ({ error: getErrorMessage(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		clearEmailError: assign({ emailError: () => void 0 }),
+		setOtpCode: assign(({ event }) => ({
+			otpCode: event.code,
+			otpError: void 0
+		})),
+		setOtpError: assign(({ context, event }) => ({
+			otpError: getErrorMessage(event.error),
+			attemptsRemaining: context.attemptsRemaining - 1
+		})),
+		setOtpRequestError: assign(({ event }) => ({ otpError: getErrorMessage(event.error) })),
+		clearOtpError: assign({
+			otpError: () => void 0,
+			otpCode: () => ""
+		}),
+		startResendTimer: assign({
+			resendTimer: () => RESEND_TIMER_SECONDS,
+			resendTimerActive: () => true
+		}),
+		tickResendTimer: assign(({ context }) => {
+			const newTimer = Math.max(0, context.resendTimer - 1);
+			return {
+				resendTimer: newTimer,
+				resendTimerActive: newTimer > 0
+			};
+		}),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			email: "",
+			isValid: false,
+			emailError: void 0,
+			prefilledEmail: void 0,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false
+		}))
+	},
+	guards: {
+		hasPrefill: ({ context }) => context.config.prefill === true,
+		hasOtpVerification: ({ context }) => context.config.otpVerification,
+		isValidEmail: ({ context }) => context.isValid,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 1,
+		canResend: ({ context }) => !context.resendTimerActive
+	}
+}).createMachine({
+	id: "email",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		email: "",
+		isValid: false,
+		emailError: void 0,
+		prefilledEmail: void 0,
+		error: void 0,
+		otpCode: "",
+		otpError: void 0,
+		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
+		resendTimer: 0,
+		resendTimerActive: false
+	}),
+	states: {
+		idle: { on: { LOAD: [{
+			target: "loadingPrefill",
+			guard: "hasPrefill"
+		}, { target: "inputting" }] } },
+		loadingPrefill: { invoke: {
+			id: "fetchEmail",
+			src: "fetchEmail",
+			onDone: {
+				target: "inputting",
+				actions: "setPrefilledEmail"
+			},
+			onError: { target: "inputting" }
+		} },
+		inputting: { on: {
+			EMAIL_CHANGED: { actions: "setEmail" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "isValidEmail",
+				actions: "clearEmailError"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitEmail",
+			src: "submitEmail",
+			input: ({ context }) => ({ email: context.email }),
+			onDone: [{
+				target: "sendingInitialOtp",
+				guard: "hasOtpVerification"
+			}, { target: "finished" }],
+			onError: {
+				target: "inputting",
+				actions: "setEmailError"
+			}
+		} },
+		sendingInitialOtp: { invoke: {
+			id: "sendOtp",
+			src: "sendOtp",
+			onDone: {
+				target: "awaitingOtp",
+				actions: "startResendTimer"
+			},
+			onError: {
+				target: "otpError",
+				actions: ["setOtpRequestError", "startResendTimer"]
+			}
+		} },
+		resendingOtp: { invoke: {
+			id: "sendOtp",
+			src: "sendOtp",
+			onDone: {
+				target: "awaitingOtp",
+				actions: "startResendTimer"
+			},
+			onError: {
+				target: "otpError",
+				actions: ["setOtpRequestError", "startResendTimer"]
+			}
+		} },
+		awaitingOtp: {
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer",
+				input: ({ context }) => ({ seconds: context.resendTimer })
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: { actions: "setOtpCode" },
+				VERIFY_OTP: { target: "verifyingOtp" },
+				RESEND_OTP: {
+					target: "resendingOtp",
+					guard: "canResend"
+				},
+				BACK: { target: "inputting" }
+			}
+		},
+		verifyingOtp: { invoke: {
+			id: "verifyOtp",
+			src: "verifyOtp",
+			input: ({ context }) => ({ code: context.otpCode }),
+			onDone: [
+				{
+					target: "finished",
+					guard: ({ event }) => event.output.success === true
+				},
+				{
+					target: "otpError",
+					guard: "hasAttemptsRemaining",
+					actions: assign(({ context }) => ({
+						otpError: "otp.errorv2",
+						attemptsRemaining: context.attemptsRemaining - 1
+					}))
+				},
+				{
+					target: "error",
+					actions: assign({ error: () => "Maximum OTP attempts exceeded" })
+				}
+			],
+			onError: [{
+				target: "otpError",
+				guard: "hasAttemptsRemaining",
+				actions: "setOtpError"
+			}, {
+				target: "error",
+				actions: "setError"
+			}]
+		} },
+		otpError: {
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer",
+				input: ({ context }) => ({ seconds: context.resendTimer })
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: {
+					target: "awaitingOtp",
+					actions: "setOtpCode"
+				},
+				RESEND_OTP: {
+					target: "resendingOtp",
+					guard: "canResend"
+				},
+				BACK: { target: "inputting" }
+			}
+		},
+		finished: { type: "final" },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+export { emailMachine as t };

package/dist/endpoints-CnN3SyDa.esm.js

@@ -0,0 +1,87 @@
+//#region src/internal/http/endpoints.ts
+const endpoints = {
+	createSession: "/omni/start",
+	flow: "/omni/onboarding/flow",
+	events: "/omni/interview-events",
+	selfie: "/omni/add/face",
+	authenticate: "/omni/onboarding-authentications/authenticate",
+	recordingCreateSessionV2: "/omni/recordings/create-session/v2",
+	recordingStartV2: "/omni/recordings/record-start/v2",
+	recordingStopV2: "/omni/recordings/record-stop/v2",
+	deepsightVideoImport: "/omni/recordings/import",
+	phone: "/omni/add/phone",
+	phoneInstant: "/omni/instant/add/phone",
+	getPhone: "/omni/get/phone",
+	startInfo: "/omni/start-info",
+	sendSmsOtp: "/omni/send/sms-otp",
+	compareOtp: "/omni/compare/otp",
+	email: "/omni/add/email",
+	getEmail: "/omni/get/email",
+	frontId: "/omni/add/front-id/v2",
+	backId: "/omni/add/back-id/v2",
+	frontSecondId: "/omni/add/front-second-id/v2",
+	backSecondId: "/omni/add/back-second-id/v2",
+	getImages: "/omni/get/images",
+	getImagesV2: "/omni/get/images/v2",
+	getScore: "/omni/get/score",
+	getImagesSecondId: "/omni/get/images-second-id",
+	processId: "/omni/process/id",
+	processSecondId: "/omni/process/second-id",
+	processFace: "/omni/process/face",
+	governmentValidation: "/omni/process/government-validation",
+	deviceStats: "/omni/device/stats",
+	featureConfig: "/omni/feature-config",
+	deviceFingerprint: "/omni/add/device-fingerprint",
+	onboardingStatus: "/omni/get/onboarding/status",
+	customFields: "/omni/get/custom-fields",
+	addCustomFields: "/omni/add/custom-fields",
+	deviceRiskClientId: "/omni/device-risk-client-id",
+	ocrData: "/omni/get/ocr-data",
+	ocrDataSecondId: "/omni/get/ocr-data-second-id",
+	updateEditableOcrData: "/omni/update/editable-ocr-data",
+	updateEditableOcrDataSecondId: "/omni/update/editable-ocr-data-second-id",
+	addCurp: "/omni/add/curp",
+	addCurpV2: "/omni/add/curp/v2",
+	addGeolocation: "/omni/add/geolocation",
+	ekycSubmit: "/omni/externalVerification/ekyc",
+	ekybSubmit: "/omni/externalVerification/ekyb",
+	getCombinedConsent: "/omni/get/combined-consent",
+	signCombinedConsent: "/omni/sign-combined-consent",
+	getConsents: "/omni/consents",
+	submitMlConsent: "/omni/consents/submit",
+	addressAutocomplete: "/omni/externalVerification/addressAutocomplete",
+	otpStatus: "/omni/session/otp-status",
+	moduleConfig: "/omni/flow/onboarding/configuration",
+	addDocument: "/omni/add/document/v2",
+	addressStatement: "/omni/add/address-statement/v2",
+	documentV3: "/omni/add/document/v3",
+	finalizeDocument: "/omni/finalize/document",
+	documentLegacy: "/omni/add/document",
+	cfdi: "/omni/process/cfdi",
+	finishStatus: "/omni/finish-status",
+	updateSession: "/omni/update",
+	onboardingUrl: "/omni/onboarding-url",
+	sendRedirectSms: "/omni/notify/send-sms",
+	qrRefreshUuid: "/omni/qr/refresh",
+	qrValidateUuid: "/omni/qr/validate",
+	addSignature: "/omni/add/signature",
+	addSignatureV2: "/omni/add/signature/v2",
+	identityReuseCandidates: "/omni/identity-reuse/candidates",
+	identityReuseSubmit: "/omni/identity-reuse/submit",
+	processAntifraud: "/omni/process/antifraud",
+	processWatchlist: "/omni/process/global-watchlist",
+	watchlistForBusinessSubmit: "/omni/businessWatchlist-result",
+	aesUnsignedDocuments: "/omni/es/documents/unsigned",
+	aesSignDocument: "/omni/es/process/sign",
+	qesSignDocument: "/omni/es/process/signQes",
+	aesGenerateUploadUrl: "/omni/es/generateDocumentUploadUrl",
+	workflowCurrentNode: "/omni/workflow/current/node",
+	workflowProcessNode: "/omni/workflow/process/node",
+	workflowInfo: "/omni/workflow/info",
+	customModuleExecution: "/omni/custom-module/execution",
+	processCrossDocumentDataMatch: "/omni/cross-doc-data-check/process",
+	dynamicFormsSubmitAnswer: "/omni/form-answer/submit"
+};
+
+//#endregion
+export { endpoints as t };