@incodetech/core 2.0.1 → 2.1.0-rc.1

package/dist/geolocation.esm.js

@@ -1,9 +1,9 @@
 import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import "./platform-CfrjKhmi.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-asasuHY2.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-Dvh7X0wF.esm.js";
 
 //#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
 var BrowserGeolocationProvider = class {
@@ -37,7 +37,7 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
 	if (typedSnapshot.matches("locationAcquired")) return {
 		status: "locationAcquired",
-		location: context.location ?? "Unknown"
+		location: context.location ?? null
 	};
 	if (typedSnapshot.matches("permissionDenied")) return {
 		status: "permissionDenied",

package/dist/{geolocationStateMachine-asasuHY2.esm.js → geolocationStateMachine-Dvh7X0wF.esm.js}

@@ -1,7 +1,7 @@
 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 { r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-SKvEfCBh.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
 //#region src/modules/geolocation/geolocationServices.ts
 async function addGeolocation(params, signal) {
@@ -34,7 +34,7 @@ const geolocationMachine = setup({
 			try {
 				return await addGeolocation(input, signal);
 			} catch {
-				return { location: "Unknown" };
+				return { location: null };
 			}
 		})
 	},
@@ -89,7 +89,7 @@ const geolocationMachine = setup({
 			},
 			onError: {
 				target: "locationAcquired",
-				actions: assign({ location: () => "Unknown" })
+				actions: assign({ location: () => null })
 			}
 		} },
 		locationAcquired: { on: { CONTINUE: { target: "finished" } } },

package/dist/getBrowser-C8DP7oTB.esm.js

@@ -0,0 +1,8 @@
+//#region ../infra/src/device/getBrowser.ts
+function getUserAgent() {
+	if (typeof navigator === "undefined") return "";
+	return navigator.userAgent;
+}
+
+//#endregion
+export { getUserAgent as t };

package/dist/{getBrowser-BSXUTWXw.esm.js → getDeviceClass-C0olyNFS.esm.js}

@@ -31,11 +31,4 @@ function getWindowDimensions(defaultWidth = 1280, defaultHeight = 720) {
 }
 
 //#endregion
-//#region ../infra/src/device/getBrowser.ts
-function getUserAgent() {
-	if (typeof navigator === "undefined") return "";
-	return navigator.userAgent;
-}
-
-//#endregion
-export { getDeviceInfo as n, getWindowDimensions as r, getUserAgent as t };
+export { getWindowDimensions as n, getDeviceInfo as t };

package/dist/{getDeviceClass-BSntT9_j.esm.js → getDeviceClass-C8Do2qYu.esm.js}

@@ -1,4 +1,4 @@
-import { n as getDeviceInfo } from "./getBrowser-BSXUTWXw.esm.js";
+import { t as getDeviceInfo } from "./getDeviceClass-C0olyNFS.esm.js";
 
 //#region src/internal/device/getDeviceClass.ts
 function getDeviceClass() {

package/dist/government-validation.d.ts

@@ -1,16 +1,26 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { t as OtpValidationErrors } from "./otp-DF5A0sFx.js";
 
 //#region src/modules/government-validation/types.d.ts
 type GovernmentValidationConfig = {
-  validationCountries: string[];
+  validationCountries?: string[];
+  faceAndDataValidation?: boolean;
+  addressValidation?: boolean;
+  faceMatchOverrideDataScore?: boolean;
+  useCroppedIdFacePhoto?: boolean;
+  alternativeFacialValidation?: boolean;
+  fallbackEnabled?: boolean;
+  scrapingMethod?: boolean;
+  scrapingV2?: boolean;
+  scrapingV3?: boolean;
+  failUnsupportedId?: boolean;
+  mockConnectionError?: boolean;
+  mockUserNotFoundError?: boolean;
+  mockOK?: boolean;
   facialValidation: boolean;
   dataValidation: boolean;
-  faceAndDataValidation: boolean;
-  addressValidation: boolean;
   backgroundExecution: boolean;
-  faceMatchOverrideDataScore: boolean;
-  useCroppedIdFacePhoto: boolean;
   maxOtpAttempts?: number;
 };
 //#endregion
@@ -39,9 +49,15 @@ type GovernmentValidationAwaitingOtpState = {
   canResend: boolean;
   attemptsRemaining: number;
   otpError?: string;
+  otpCode: string;
+  otpLength: number;
+  otpValidationErrors?: OtpValidationErrors;
+  isOtpValid: boolean;
 };
 type GovernmentValidationVerifyingOtpState = {
   status: 'verifyingOtp';
+  otpCode: string;
+  otpLength: number;
 };
 type GovernmentValidationFinishedState = {
   status: 'finished';
@@ -50,14 +66,18 @@ type GovernmentValidationErrorState = {
   status: 'error';
   error: string;
 };
+type GovernmentValidationSuccessState = {
+  status: 'displaySuccess';
+};
 type GovernmentValidationUnknownState = {
   status: 'unknown';
   error: string;
 };
-type GovernmentValidationState = GovernmentValidationIdleState | GovernmentValidationLoadingState | GovernmentValidationProcessingState | GovernmentValidationAwaitingOtpState | GovernmentValidationVerifyingOtpState | GovernmentValidationFinishedState | GovernmentValidationErrorState | GovernmentValidationUnknownState;
+type GovernmentValidationState = GovernmentValidationIdleState | GovernmentValidationLoadingState | GovernmentValidationProcessingState | GovernmentValidationAwaitingOtpState | GovernmentValidationVerifyingOtpState | GovernmentValidationFinishedState | GovernmentValidationErrorState | GovernmentValidationSuccessState | GovernmentValidationUnknownState;
 declare function createGovernmentValidationManager(options: CreateGovernmentValidationActorOptions): Manager<GovernmentValidationState> & {
   load(): void;
   setOtpCode(code: string): void;
+  validateOtp(): void;
   submitOtp(code: string): void;
   resendOtp(): void;
   retry(): void;

package/dist/government-validation.esm.js

@@ -1,9 +1,10 @@
 import "./BrowserTimerProvider-DhNc_x02.esm.js";
 import "./api-CESGtpbH.esm.js";
-import { o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as governmentValidationMachine } from "./governmentValidationStateMachine-BDDYrJTo.esm.js";
+import { o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as OTP_CODE_LENGTH } from "./otp-CGMdUzBC.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-DcJ-BfsC.esm.js";
 
 //#region src/modules/government-validation/governmentValidationActor.ts
 function createGovernmentValidationActor(options) {
@@ -17,16 +18,23 @@ function mapState(snapshot) {
 	const { context } = typedSnapshot;
 	if (typedSnapshot.matches("idle")) return { status: "idle" };
 	if (typedSnapshot.matches("loading")) return { status: "loading" };
-	if (typedSnapshot.matches("polling") || typedSnapshot.matches("pollingRequest")) return { status: "processing" };
 	if (typedSnapshot.matches("awaitingOtp")) return {
 		status: "awaitingOtp",
 		resendTimer: context.resendTimer,
 		canResend: !context.resendTimerActive,
 		attemptsRemaining: context.attemptsRemaining,
-		otpError: context.otpError
+		otpError: context.otpError,
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH,
+		otpValidationErrors: context.otpValidationErrors,
+		isOtpValid: Object.keys(context.otpValidationErrors ?? {}).length === 0
 	};
-	if (typedSnapshot.matches("verifyingOtp")) return { status: "verifyingOtp" };
-	if (typedSnapshot.matches("displaySuccess")) return { status: "finished" };
+	if (typedSnapshot.matches("verifyingOtp")) return {
+		status: "verifyingOtp",
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH
+	};
+	if (typedSnapshot.matches("displaySuccess")) return { status: "displaySuccess" };
 	if (typedSnapshot.matches("displayProcessing")) return { status: "processing" };
 	if (typedSnapshot.matches("finished")) return { status: "finished" };
 	if (typedSnapshot.matches("displayError")) return {
@@ -50,6 +58,9 @@ function createApi({ actor, trackElementClicked }) {
 				code
 			});
 		},
+		validateOtp() {
+			actor.send({ type: "VALIDATE_OTP" });
+		},
 		submitOtp(code) {
 			trackElementClicked?.("submitOtp");
 			actor.send({

package/dist/{governmentValidationStateMachine-BDDYrJTo.esm.js → governmentValidationStateMachine-DcJ-BfsC.esm.js}

@@ -1,7 +1,8 @@
 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";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-CGMdUzBC.esm.js";
 
 //#region src/modules/government-validation/governmentValidationServices.ts
 async function processGovernmentValidation(signal) {
@@ -18,8 +19,6 @@ async function submitGovernmentValidationOtp(params, signal) {
 //#endregion
 //#region src/modules/government-validation/governmentValidationStateMachine.ts
 const RESEND_TIMER_SECONDS = 30;
-const POLL_INTERVAL_MS = 2e3;
-const MAX_POLL_COUNT = 60;
 const AUTO_PROCEED_DELAY_MS = 3e3;
 const governmentValidationMachine = setup({
 	types: {
@@ -35,13 +34,6 @@ const governmentValidationMachine = setup({
 		submitOtp: fromPromise(async ({ input, signal }) => {
 			return submitGovernmentValidationOtp({ code: input.code }, signal);
 		}),
-		pollingTimer: fromCallback(({ sendBack }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			const interval = timer.setInterval(() => {
-				sendBack({ type: "POLL" });
-			}, POLL_INTERVAL_MS);
-			return () => timer.clearInterval(interval);
-		}),
 		resendTimer: fromCallback(({ sendBack }) => {
 			const timer = BrowserTimerProvider.getInstance();
 			let seconds = RESEND_TIMER_SECONDS;
@@ -60,15 +52,21 @@ const governmentValidationMachine = setup({
 		clearError: assign({ error: () => void 0 }),
 		setOtpCode: assign(({ event }) => ({
 			otpCode: event.code,
-			otpError: void 0
+			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: () => ""
+			otpCode: () => "",
+			otpValidationErrors: () => void 0
 		}),
 		startResendTimer: assign({
 			resendTimer: () => RESEND_TIMER_SECONDS,
@@ -81,28 +79,27 @@ const governmentValidationMachine = setup({
 				resendTimerActive: newTimer > 0
 			};
 		}),
-		incrementPollCount: assign(({ context }) => ({ pollCount: context.pollCount + 1 })),
-		resetPollCount: assign({ pollCount: () => 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,
-			pollCount: 0
+			resendTimerActive: false
 		}))
 	},
 	guards: {
+		isBackgroundExecution: ({ context }) => context.config.backgroundExecution,
 		isProcessing: (_, params) => params.response.statusCode === -1,
-		isSuccess: (_, params) => params.response.statusCode === 0 && params.response.validationStatus?.status !== "UNKNOWN",
-		isError: (_, params) => params.response.statusCode > 0,
+		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.validationStatus?.status === "UNKNOWN",
+		isUnknown: (_, params) => params.response.governmentValidation?.validationStatus?.status === "UNKNOWN",
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		canResend: ({ context }) => !context.resendTimerActive,
-		hasReachedMaxPolls: ({ context }) => context.pollCount >= MAX_POLL_COUNT
+		hasCompleteOtp: ({ context }) => isOtpComplete(context.otpCode),
+		canResend: ({ context }) => !context.resendTimerActive
 	}
 }).createMachine({
 	id: "governmentValidation",
@@ -112,10 +109,10 @@ const governmentValidationMachine = setup({
 		error: void 0,
 		otpCode: "",
 		otpError: void 0,
+		otpValidationErrors: void 0,
 		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
 		resendTimer: 0,
-		resendTimerActive: false,
-		pollCount: 0
+		resendTimerActive: false
 	}),
 	states: {
 		idle: { on: { LOAD: { target: "loading" } } },
@@ -123,6 +120,10 @@ const governmentValidationMachine = setup({
 			id: "processValidation",
 			src: "processValidation",
 			onDone: [
+				{
+					target: "finished",
+					guard: "isBackgroundExecution"
+				},
 				{
 					target: "awaitingOtp",
 					guard: {
@@ -138,7 +139,7 @@ const governmentValidationMachine = setup({
 					}
 				},
 				{
-					target: "polling",
+					target: "displayProcessing",
 					guard: {
 						type: "isProcessing",
 						params: ({ event }) => ({ response: event.output })
@@ -157,60 +158,13 @@ const governmentValidationMachine = setup({
 					actions: "setErrorFromResponse"
 				}
 			],
-			onError: {
-				target: "displayError",
-				actions: "setError"
-			}
-		} },
-		polling: {
-			invoke: {
-				id: "pollingTimer",
-				src: "pollingTimer"
-			},
-			on: { POLL: [{
-				target: "displayError",
-				guard: "hasReachedMaxPolls",
-				actions: assign({ error: () => "Validation timed out" })
+			onError: [{
+				target: "finished",
+				guard: "isBackgroundExecution"
 			}, {
-				target: "pollingRequest",
-				actions: "incrementPollCount"
-			}] }
-		},
-		pollingRequest: { invoke: {
-			id: "pollValidation",
-			src: "processValidation",
-			onDone: [
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "polling",
-					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: "displayError",
 				actions: "setError"
-			}
+			}]
 		} },
 		awaitingOtp: {
 			entry: "startResendTimer",
@@ -221,7 +175,11 @@ const governmentValidationMachine = setup({
 			on: {
 				TICK: { actions: "tickResendTimer" },
 				OTP_CHANGED: { actions: "setOtpCode" },
-				SUBMIT_OTP: { target: "verifyingOtp" },
+				VALIDATE_OTP: { actions: "validateOtpField" },
+				SUBMIT_OTP: [{
+					guard: "hasCompleteOtp",
+					target: "verifyingOtp"
+				}, { actions: "validateOtpField" }],
 				RESEND_OTP: {
 					target: "loading",
 					guard: "canResend"

package/dist/home.d.ts

@@ -1,8 +1,9 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./camera-DBSxa6ML.js";
-import "./types-CFV9G_7j.js";
-import { t as EmptyConfig } from "./types-BP1m8VRw.js";
-import * as xstate721 from "xstate";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./camera-SRBpPq2X.js";
+import "./types-Bj9hdFjU.js";
+import "./types-DvGZI7BF.js";
+import { t as EmptyConfig } from "./types-DOUhndhT.js";
+import * as xstate1070 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -34,41 +35,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate721.StateMachine<HomeContext, {
+declare const homeMachine: xstate1070.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate721.NonReducibleUnknown, xstate721.EventObject, xstate721.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate1070.NonReducibleUnknown, xstate1070.EventObject, xstate1070.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate721.ActorRefFromLogic<never>;
-      <TLogic extends xstate721.AnyActorLogic>(src: TLogic, ...[options]: xstate721.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate1070.ActorRefFromLogic<never>;
+      <TLogic extends xstate1070.AnyActorLogic>(src: TLogic, ...[options]: xstate1070.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate721.InputFrom<TLogic> | undefined;
+        input?: xstate1070.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate721.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate721.IsNotNever<xstate721.RequiredLogicInput<TLogic>>>): xstate721.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate1070.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1070.IsNotNever<xstate1070.RequiredLogicInput<TLogic>>>): xstate1070.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate721.ActorRef<xstate721.MachineSnapshot<HomeContext, {
+    self: xstate1070.ActorRef<xstate1070.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate721.AnyActorRef | undefined>, xstate721.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate1070.AnyActorRef | undefined>, xstate1070.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate721.AnyEventObject>;
+    }, xstate1070.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };

package/dist/home.esm.js

@@ -1,6 +1,6 @@
 import "./api-CESGtpbH.esm.js";
-import { o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { c as createManager, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { c as createManager, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
 //#region src/modules/home/homeStateMachine.ts
 const homeMachine = setup({ types: {

package/dist/http.esm.js

@@ -1,3 +1,4 @@
 import { n as getApi, t as api } from "./api-CESGtpbH.esm.js";
+import "./http-Cai3IoLS.esm.js";
 
 export { api, getApi };