@incodetech/core 0.0.0-dev-20260819-588cf821 → 0.0.0-dev-20260819-d97c25cd

package/dist/governmentValidationStateMachine-BYKYUdza.esm.js

@@ -1,226 +0,0 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.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, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { n as isOtpComplete, t as computeOtpValidationErrors } from "./otp-D2k3PeSL.esm.js";
-//#region src/modules/government-validation/governmentValidationServices.ts
-async function processGovernmentValidation(signal) {
-	const res = await api.post(endpoints.governmentValidation, {}, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function submitGovernmentValidationOtp(params, signal) {
-	const res = await api.post(endpoints.governmentValidation, { otpCode: params.code }, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} (OTP) failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-//#endregion
-//#region src/modules/government-validation/governmentValidationStateMachine.ts
-const RESEND_TIMER_SECONDS = 30;
-const governmentValidationMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	delays: { AUTO_PROCEED: 3e3 },
-	actors: {
-		processValidation: fromPromise(async ({ signal }) => {
-			return processGovernmentValidation(signal);
-		}),
-		submitOtp: fromPromise(async ({ input, signal }) => {
-			return submitGovernmentValidationOtp({ code: input.code }, signal);
-		}),
-		resendTimer: fromCallback(({ sendBack }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			let seconds = RESEND_TIMER_SECONDS;
-			const interval = timer.setInterval(() => {
-				seconds -= 1;
-				sendBack({ type: "TICK" });
-				if (seconds <= 0) timer.clearInterval(interval);
-			}, 1e3);
-			return () => timer.clearInterval(interval);
-		})
-	},
-	actions: {
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		setErrorFromResponse: assign({ error: () => "Government validation failed" }),
-		setUnknownError: assign({ error: () => "Unknown validation status" }),
-		clearError: assign({ error: () => void 0 }),
-		setOtpCode: assign(({ event }) => ({
-			otpCode: event.code,
-			otpError: void 0,
-			otpValidationErrors: void 0
-		})),
-		validateOtpField: assign(({ context }) => {
-			const errors = computeOtpValidationErrors(context.otpCode);
-			return { otpValidationErrors: errors.otp ? errors : void 0 };
-		}),
-		setOtpError: assign(({ context }) => ({
-			otpError: "Invalid OTP code",
-			attemptsRemaining: context.attemptsRemaining - 1
-		})),
-		clearOtpError: assign({
-			otpError: () => void 0,
-			otpCode: () => "",
-			otpValidationErrors: () => void 0
-		}),
-		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,
-			error: void 0,
-			otpCode: "",
-			otpError: void 0,
-			otpValidationErrors: void 0,
-			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
-			resendTimer: 0,
-			resendTimerActive: false
-		}))
-	},
-	guards: {
-		isBackgroundExecution: ({ context }) => context.config.backgroundExecution,
-		isProcessing: (_, params) => params.response.statusCode === -1,
-		isSuccess: (_, params) => params.response.statusCode === 0 && params.response.governmentValidation?.validationStatus?.status === "OK",
-		isError: (_, params) => params.response.statusCode > 0 || params.response.governmentValidation?.validationStatus?.status === "FAIL",
-		isOtpRequested: (_, params) => params.response.otpResponse?.authBridge?.otpCodeRequested === true,
-		isUnknown: (_, params) => params.response.governmentValidation?.validationStatus?.status === "UNKNOWN",
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		hasCompleteOtp: ({ context }) => isOtpComplete(context.otpCode),
-		canResend: ({ context }) => !context.resendTimerActive
-	}
-}).createMachine({
-	id: "governmentValidation",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		error: void 0,
-		otpCode: "",
-		otpError: void 0,
-		otpValidationErrors: void 0,
-		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
-		resendTimer: 0,
-		resendTimerActive: false
-	}),
-	states: {
-		idle: { on: { LOAD: { target: "loading" } } },
-		loading: { invoke: {
-			id: "processValidation",
-			src: "processValidation",
-			onDone: [
-				{
-					target: "finished",
-					guard: "isBackgroundExecution"
-				},
-				{
-					target: "awaitingOtp",
-					guard: {
-						type: "isOtpRequested",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displayProcessing",
-					guard: {
-						type: "isProcessing",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displayUnknown",
-					guard: {
-						type: "isUnknown",
-						params: ({ event }) => ({ response: event.output })
-					},
-					actions: "setUnknownError"
-				},
-				{
-					target: "displayError",
-					actions: "setErrorFromResponse"
-				}
-			],
-			onError: [{
-				target: "finished",
-				guard: "isBackgroundExecution"
-			}, {
-				target: "displayError",
-				actions: "setError"
-			}]
-		} },
-		awaitingOtp: {
-			entry: "startResendTimer",
-			invoke: {
-				id: "resendTimer",
-				src: "resendTimer"
-			},
-			on: {
-				TICK: { actions: "tickResendTimer" },
-				OTP_CHANGED: { actions: "setOtpCode" },
-				VALIDATE_OTP: { actions: "validateOtpField" },
-				SUBMIT_OTP: [{
-					guard: "hasCompleteOtp",
-					target: "verifyingOtp"
-				}, { actions: "validateOtpField" }],
-				RESEND_OTP: {
-					target: "loading",
-					guard: "canResend"
-				}
-			}
-		},
-		verifyingOtp: { invoke: {
-			id: "submitOtp",
-			src: "submitOtp",
-			input: ({ context }) => ({ code: context.otpCode }),
-			onDone: [
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "awaitingOtp",
-					guard: "hasAttemptsRemaining",
-					actions: "setOtpError"
-				},
-				{
-					target: "displayError",
-					actions: assign({ error: () => "Maximum OTP attempts exceeded" })
-				}
-			],
-			onError: [{
-				target: "awaitingOtp",
-				guard: "hasAttemptsRemaining",
-				actions: "setOtpError"
-			}, {
-				target: "displayError",
-				actions: "setError"
-			}]
-		} },
-		displaySuccess: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayProcessing: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayError: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayUnknown: { after: { AUTO_PROCEED: { target: "finished" } } },
-		finished: { type: "final" }
-	}
-});
-//#endregion
-export { governmentValidationMachine as t };

package/dist/trueSight-B-rervIk.esm.js

@@ -1 +0,0 @@
-import "./trueSightService-CFXnK5HX.esm.js";

package/dist/types-Dm7dzIXw.d.ts

@@ -1,6 +0,0 @@
-import { i as FlowModuleConfig } from "./types-DNNUCM_n.js";
-import { t as BaseFaceCaptureConfig } from "./types-CaqgEfzk.js";
-//#region src/modules/authentication/types.d.ts
-type AuthenticationConfig = FlowModuleConfig['AUTHENTICATION'] & BaseFaceCaptureConfig;
-//#endregion
-export { AuthenticationConfig as t };