@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/government-validation.esm.js

@@ -1,81 +0,0 @@
-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

@@ -1,271 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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 xstate0 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: xstate0.StateMachine<HomeContext, {
-  type: "LOAD";
-} | {
-  type: "COMPLETE";
-} | {
-  type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate0.NonReducibleUnknown, xstate0.EventObject, xstate0.MetaObject, {
-  readonly id: "home";
-  readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
-    spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate0.ActorRefFromLogic<never>;
-      <TLogic extends xstate0.AnyActorLogic>(src: TLogic, ...[options]: xstate0.ConditionalRequired<[options?: ({
-        id?: never;
-        systemId?: string;
-        input?: xstate0.InputFrom<TLogic> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in xstate0.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate0.IsNotNever<xstate0.RequiredLogicInput<TLogic>>>): xstate0.ActorRefFromLogic<TLogic>;
-    };
-    input: HomeInput;
-    self: xstate0.ActorRef<xstate0.MachineSnapshot<HomeContext, {
-      type: "LOAD";
-    } | {
-      type: "COMPLETE";
-    } | {
-      type: "RESET";
-    }, Record<string, xstate0.AnyActorRef | undefined>, xstate0.StateValue, string, unknown, any, any>, {
-      type: "LOAD";
-    } | {
-      type: "COMPLETE";
-    } | {
-      type: "RESET";
-    }, xstate0.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

@@ -1,61 +0,0 @@
-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

@@ -1,68 +0,0 @@
-//#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

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