@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/government-validation.esm.js

@@ -0,0 +1,81 @@
+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";
+
+//#region src/modules/government-validation/governmentValidationActor.ts
+function createGovernmentValidationActor(options) {
+	return createActor(governmentValidationMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/government-validation/governmentValidationManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = 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
+	};
+	if (typedSnapshot.matches("verifyingOtp")) return { status: "verifyingOtp" };
+	if (typedSnapshot.matches("displaySuccess")) return { status: "finished" };
+	if (typedSnapshot.matches("displayProcessing")) return { status: "processing" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("displayError")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	if (typedSnapshot.matches("displayUnknown")) return {
+		status: "unknown",
+		error: context.error ?? "Unknown validation status"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setOtpCode(code) {
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+		},
+		submitOtp(code) {
+			trackElementClicked?.("submitOtp");
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+			actor.send({ type: "SUBMIT_OTP" });
+		},
+		resendOtp() {
+			trackElementClicked?.("resendOtp");
+			actor.send({ type: "RESEND_OTP" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+function createGovernmentValidationManager(options) {
+	return createManager({
+		actor: createGovernmentValidationActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation("GOVERNMENT_VALIDATION")
+	});
+}
+
+//#endregion
+export { createGovernmentValidationManager, governmentValidationMachine };

package/dist/governmentValidationStateMachine-BDDYrJTo.esm.js

@@ -0,0 +1,271 @@
+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/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 POLL_INTERVAL_MS = 2e3;
+const MAX_POLL_COUNT = 60;
+const AUTO_PROCEED_DELAY_MS = 3e3;
+const governmentValidationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	delays: { AUTO_PROCEED: AUTO_PROCEED_DELAY_MS },
+	actors: {
+		processValidation: fromPromise(async ({ signal }) => {
+			return processGovernmentValidation(signal);
+		}),
+		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;
+			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
+		})),
+		setOtpError: assign(({ context }) => ({
+			otpError: "Invalid OTP code",
+			attemptsRemaining: context.attemptsRemaining - 1
+		})),
+		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
+			};
+		}),
+		incrementPollCount: assign(({ context }) => ({ pollCount: context.pollCount + 1 })),
+		resetPollCount: assign({ pollCount: () => 0 }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false,
+			pollCount: 0
+		}))
+	},
+	guards: {
+		isProcessing: (_, params) => params.response.statusCode === -1,
+		isSuccess: (_, params) => params.response.statusCode === 0 && params.response.validationStatus?.status !== "UNKNOWN",
+		isError: (_, params) => params.response.statusCode > 0,
+		isOtpRequested: (_, params) => params.response.otpResponse?.authBridge?.otpCodeRequested === true,
+		isUnknown: (_, params) => params.response.validationStatus?.status === "UNKNOWN",
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		canResend: ({ context }) => !context.resendTimerActive,
+		hasReachedMaxPolls: ({ context }) => context.pollCount >= MAX_POLL_COUNT
+	}
+}).createMachine({
+	id: "governmentValidation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		error: void 0,
+		otpCode: "",
+		otpError: void 0,
+		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
+		resendTimer: 0,
+		resendTimerActive: false,
+		pollCount: 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "loading" } } },
+		loading: { invoke: {
+			id: "processValidation",
+			src: "processValidation",
+			onDone: [
+				{
+					target: "awaitingOtp",
+					guard: {
+						type: "isOtpRequested",
+						params: ({ event }) => ({ response: event.output })
+					}
+				},
+				{
+					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"
+			}
+		} },
+		polling: {
+			invoke: {
+				id: "pollingTimer",
+				src: "pollingTimer"
+			},
+			on: { POLL: [{
+				target: "displayError",
+				guard: "hasReachedMaxPolls",
+				actions: assign({ error: () => "Validation timed out" })
+			}, {
+				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",
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer"
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: { actions: "setOtpCode" },
+				SUBMIT_OTP: { target: "verifyingOtp" },
+				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/home.d.ts

@@ -0,0 +1,99 @@
+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 xstate634 from "xstate";
+
+//#region src/modules/home/types.d.ts
+type HomeConfig = EmptyConfig;
+//#endregion
+//#region src/modules/home/homeManager.d.ts
+type HomeIdleState = {
+  status: 'idle';
+};
+type HomeMainState = {
+  status: 'main';
+};
+type HomeFinishedState = {
+  status: 'finished';
+};
+type HomeState = HomeIdleState | HomeMainState | HomeFinishedState;
+declare function createHomeManager(options?: {
+  config?: HomeConfig;
+}): Manager<HomeState> & {
+  load(): void;
+  complete(): void;
+  reset(): void;
+};
+type HomeManager = ReturnType<typeof createHomeManager>;
+//#endregion
+//#region src/modules/home/homeStateMachine.d.ts
+type HomeContext = {
+  config: EmptyConfig;
+};
+type HomeInput = {
+  config: EmptyConfig;
+};
+declare const homeMachine: xstate634.StateMachine<HomeContext, {
+  type: "LOAD";
+} | {
+  type: "COMPLETE";
+} | {
+  type: "RESET";
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate634.NonReducibleUnknown, xstate634.EventObject, xstate634.MetaObject, {
+  readonly id: "home";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate634.ActorRefFromLogic<never>;
+      <TLogic extends xstate634.AnyActorLogic>(src: TLogic, ...[options]: xstate634.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate634.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate634.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate634.IsNotNever<xstate634.RequiredLogicInput<TLogic>>>): xstate634.ActorRefFromLogic<TLogic>;
+    };
+    input: HomeInput;
+    self: xstate634.ActorRef<xstate634.MachineSnapshot<HomeContext, {
+      type: "LOAD";
+    } | {
+      type: "COMPLETE";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate634.AnyActorRef | undefined>, xstate634.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "COMPLETE";
+    } | {
+      type: "RESET";
+    }, xstate634.AnyEventObject>;
+  }) => {
+    config: EmptyConfig;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "main";
+        };
+      };
+    };
+    readonly main: {
+      readonly on: {
+        readonly COMPLETE: {
+          readonly target: "finished";
+        };
+        readonly RESET: {
+          readonly target: "idle";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+export { type HomeConfig, type HomeManager, type HomeState, createHomeManager, homeMachine };

package/dist/home.esm.js

@@ -0,0 +1,61 @@
+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";
+
+//#region src/modules/home/homeStateMachine.ts
+const homeMachine = setup({ types: {
+	context: {},
+	events: {},
+	input: {}
+} }).createMachine({
+	id: "home",
+	initial: "idle",
+	context: ({ input }) => ({ config: input.config }),
+	states: {
+		idle: { on: { LOAD: { target: "main" } } },
+		main: { on: {
+			COMPLETE: { target: "finished" },
+			RESET: { target: "idle" }
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/home/homeActor.ts
+function createHomeActor(options = {}) {
+	return createActor(homeMachine, { input: { config: options.config ?? {} } }).start();
+}
+
+//#endregion
+//#region src/modules/home/homeManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("main")) return { status: "main" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		complete() {
+			actor.send({ type: "COMPLETE" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createHomeManager(options = {}) {
+	return createManager({
+		actor: createHomeActor({ config: options.config }),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation("HOME")
+	});
+}
+
+//#endregion
+export { createHomeManager, homeMachine };

package/dist/http.d.ts

@@ -0,0 +1,68 @@
+//#region ../infra/src/http/types.d.ts
+
+type RequestConfig = {
+  method?: string;
+  url: string;
+  headers?: Record<string, string>;
+  query?: Record<string, string | number | boolean | undefined>;
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: unknown;
+  signal?: AbortSignal;
+  timeout?: number;
+  parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
+  onUploadProgress?: (progress: number) => void;
+  keepalive?: boolean;
+  /**
+   * Transport-internal flag: the request body has already been inline-
+   * encrypted by C++ `SessionEncryptor` (used only by the on-device face-
+   * results path). When true, `createWasmApi` attaches the SHA-256 OAEP
+   * scheme header so the server can unwrap the embedded AES key, and
+   * forwards the flag to the WASM WebClient so it does not double-encrypt.
+   * Ignored by non-WASM transports.
+   */
+  ie?: boolean;
+};
+type HttpResponse<T = unknown> = {
+  ok: boolean;
+  status: number;
+  statusText: string;
+  url: string;
+  headers: Record<string, string>;
+  data: T;
+};
+type HttpClient = {
+  defaults: {
+    baseURL: string;
+    headers: Record<string, string>;
+  };
+  request<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
+  get<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  post<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  put<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  patch<T = unknown>(url: string, body?: unknown, config?: Omit<RequestConfig, 'method' | 'url' | 'body'>): Promise<HttpResponse<T>>;
+  delete<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  head<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  options<T = unknown>(url: string, config?: Omit<RequestConfig, 'method' | 'url'>): Promise<HttpResponse<T>>;
+  setHeader(name: string, value: string): void;
+};
+//#endregion
+//#region src/internal/http/api.d.ts
+type MethodConfig = {
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+  timeout?: number;
+  query?: Record<string, string | number | boolean | undefined>;
+  onUploadProgress?: (progress: number) => void;
+  keepalive?: boolean;
+};
+type ApiClient = {
+  get<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
+  post<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  put<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  patch<T>(url: string, data?: unknown, config?: MethodConfig): Promise<HttpResponse<T>>;
+  delete<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;
+};
+declare function getApi(): HttpClient;
+declare const api: ApiClient;
+//#endregion
+export { api, getApi };

package/dist/http.esm.js

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