@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/phoneStateMachine-CuPARRaT.esm.js

@@ -0,0 +1,351 @@
+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/phone/phoneServices.ts
+function getPhoneServerFailureReason(error, invalidStatus) {
+	if (error.status === invalidStatus) return "invalidPhone";
+	return "serverError";
+}
+async function fetchPhone(signal) {
+	const res = await api.get(endpoints.getPhone, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getPhone} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function fetchStartInfo(signal) {
+	const res = await api.get(endpoints.startInfo, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addPhone(params, signal) {
+	try {
+		return (await api.post(endpoints.phone, {
+			phone: params.phone,
+			optInGranted: params.optInGranted
+		}, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error, 400));
+	}
+}
+async function addPhoneInstantVerify(params, signal) {
+	try {
+		return (await api.post(endpoints.phoneInstant, {
+			phone: params.phone,
+			optInGranted: params.optInGranted
+		}, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error, 400));
+	}
+}
+async function sendOtp(signal) {
+	try {
+		await api.get(`${endpoints.sendSmsOtp}?communicationchannel=SMS`, { signal });
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error));
+	}
+}
+async function verifyOtp(code, signal) {
+	try {
+		return (await api.get(`${endpoints.compareOtp}?code=${code}&channel=SMS`, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error));
+	}
+}
+
+//#endregion
+//#region src/modules/phone/phoneStateMachine.ts
+const RESEND_TIMER_SECONDS = 30;
+function getErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+const phoneMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchPhone: fromPromise(async ({ signal }) => {
+			return fetchPhone(signal);
+		}),
+		fetchStartInfo: fromPromise(async ({ signal }) => {
+			return fetchStartInfo(signal);
+		}),
+		submitPhone: fromPromise(async ({ input, signal }) => {
+			if (input.isInstantVerify) return addPhoneInstantVerify({
+				phone: input.phone,
+				optInGranted: input.optInGranted
+			}, signal);
+			return addPhone({
+				phone: input.phone,
+				optInGranted: input.optInGranted
+			}, signal);
+		}),
+		sendOtp: fromPromise(async ({ signal }) => {
+			return sendOtp(signal);
+		}),
+		verifyOtp: fromPromise(async ({ input, signal }) => {
+			return verifyOtp(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: {
+		setStartInfo: assign(({ event }) => {
+			const info = event.output;
+			return {
+				startInfo: info,
+				countryCode: info.ipIsoCode,
+				phonePrefix: info.phonePrefix
+			};
+		}),
+		setPrefilledPhone: assign(({ event }) => {
+			const phone = event.output.phone;
+			return {
+				prefilledPhone: phone,
+				phone
+			};
+		}),
+		setPhone: assign(({ event }) => {
+			const e = event;
+			return {
+				phone: e.phone,
+				isValid: e.isValid,
+				phoneError: void 0
+			};
+		}),
+		setPhoneError: assign(({ event }) => ({ phoneError: getErrorMessage(event.error) })),
+		setOptInGranted: assign(({ event }) => ({ optInGranted: event.granted })),
+		setError: assign(({ event }) => ({ error: getErrorMessage(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		clearPhoneError: assign({ phoneError: () => 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,
+			phone: "",
+			isValid: false,
+			phoneError: void 0,
+			countryCode: "",
+			phonePrefix: "",
+			prefilledPhone: void 0,
+			optInGranted: false,
+			startInfo: void 0,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false
+		}))
+	},
+	guards: {
+		hasPrefill: ({ context }) => context.config.prefill,
+		hasOtpVerification: ({ context }) => context.config.otpVerification,
+		isValidPhone: ({ context }) => context.isValid,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 1,
+		canResend: ({ context }) => !context.resendTimerActive
+	}
+}).createMachine({
+	id: "phone",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		phone: "",
+		isValid: false,
+		phoneError: void 0,
+		countryCode: "",
+		phonePrefix: "",
+		prefilledPhone: void 0,
+		optInGranted: false,
+		startInfo: 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: "loadingStartInfo" }] } },
+		loadingPrefill: { invoke: {
+			id: "fetchPhone",
+			src: "fetchPhone",
+			onDone: {
+				target: "loadingStartInfo",
+				actions: "setPrefilledPhone"
+			},
+			onError: { target: "loadingStartInfo" }
+		} },
+		loadingStartInfo: { invoke: {
+			id: "fetchStartInfo",
+			src: "fetchStartInfo",
+			onDone: {
+				target: "inputting",
+				actions: "setStartInfo"
+			},
+			onError: { target: "inputting" }
+		} },
+		inputting: { on: {
+			PHONE_CHANGED: { actions: "setPhone" },
+			OPT_IN_CHANGED: { actions: "setOptInGranted" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "isValidPhone",
+				actions: "clearPhoneError"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitPhone",
+			src: "submitPhone",
+			input: ({ context }) => ({
+				phone: context.phone,
+				optInGranted: context.config.optinEnabled ? context.optInGranted : void 0,
+				isInstantVerify: context.config.isInstantVerify ?? false
+			}),
+			onDone: [{
+				target: "sendingInitialOtp",
+				guard: "hasOtpVerification"
+			}, { target: "finished" }],
+			onError: {
+				target: "inputting",
+				actions: "setPhoneError"
+			}
+		} },
+		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 { phoneMachine as t };

package/dist/platform-CfrjKhmi.esm.js

@@ -0,0 +1,83 @@
+//#region ../infra/src/capabilities/platform.ts
+/**
+* Platform detection utilities for camera operations.
+* These are pure functions with no external dependencies and can be used by all layers.
+*/
+let uxType = null;
+function isTouchDevice() {
+	return (typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false) || "ontouchstart" in (typeof document !== "undefined" ? document.documentElement : {});
+}
+function isTabletWithoutAndroid(userAgent) {
+	const isLinux = /Linux/i.test(userAgent);
+	const isChrome = /Chrome/i.test(userAgent) && !/Edge/i.test(userAgent);
+	return !/Mobile|Android/i.test(userAgent) && isLinux && isChrome && isTouchDevice();
+}
+function isIOS(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
+	return /iPad|iPhone|iPod/.test(ua) || /Mac OS/.test(ua) && hasTouchPoints || /iPadOS/.test(ua);
+}
+function isAndroid(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Android/i.test(ua);
+}
+function isIPad(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
+	return /iPad/.test(ua) || /Mac OS/.test(ua) && hasTouchPoints && !/iPhone|iPod/.test(ua);
+}
+function isDesktop(userAgent) {
+	if (uxType) return uxType === "desktop";
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return !(/Mobile|Android/i.test(ua) || isTabletWithoutAndroid(ua) || isIOS(ua));
+}
+function isSafari(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Safari/i.test(ua) && !/Chrome|Chromium|Edge/i.test(ua);
+}
+const IPHONE_14_PLUS_DIMENSIONS = [
+	{
+		outerHeight: 852,
+		outerWidth: 393
+	},
+	{
+		outerHeight: 932,
+		outerWidth: 430
+	},
+	{
+		innerHeight: 631,
+		innerWidth: 375
+	},
+	{
+		innerHeight: 920,
+		innerWidth: 402
+	},
+	{
+		outerHeight: 874,
+		outerWidth: 402
+	},
+	{
+		innerHeight: 874,
+		innerWidth: 402
+	},
+	{
+		outerHeight: 912,
+		outerWidth: 420
+	},
+	{
+		outerHeight: 873,
+		outerWidth: 402
+	},
+	{
+		outerHeight: 956,
+		outerWidth: 440
+	}
+];
+function isIPhone14OrHigher() {
+	if (typeof window === "undefined") return false;
+	const { outerHeight, outerWidth, innerHeight, innerWidth } = window;
+	return IPHONE_14_PLUS_DIMENSIONS.some((dims) => dims.outerHeight === outerHeight && dims.outerWidth === outerWidth || dims.innerHeight === innerHeight && dims.innerWidth === innerWidth);
+}
+
+//#endregion
+export { isIPhone14OrHigher as a, isIPad as i, isDesktop as n, isSafari as o, isIOS as r, isAndroid as t };

package/dist/qe-signature-DFo_Cc-I.esm.js

@@ -0,0 +1,12 @@
+import { t as createElectronicSignatureManager } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+
+//#region src/modules/qe-signature/index.ts
+function createQeSignatureManager(options) {
+	return createElectronicSignatureManager({ config: {
+		...options.config,
+		variant: "qe"
+	} });
+}
+
+//#endregion
+export { createQeSignatureManager as t };

package/dist/qe-signature.d.ts

@@ -0,0 +1,25 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-BLKtMA0g.js";
+
+//#region src/modules/qe-signature/index.d.ts
+
+type QeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
+declare function createQeSignatureManager(options: {
+  config: QeSignatureConfig;
+}): Manager<ElectronicSignatureState> & {
+  load(): void;
+  setConsent(name: ConsentKey, checked: boolean): void;
+  selectFile(fileName: string, fileData: ArrayBuffer, fileUrl: string): void;
+  replaceFile(): void;
+  confirmFile(): void;
+  viewDocument(url: string): void;
+  closeDocumentView(): void;
+  sign(): void;
+  finish(): void;
+  retry(): void;
+  close(): void;
+};
+type QeSignatureManager = ReturnType<typeof createQeSignatureManager>;
+//#endregion
+export { type ConsentChecks, QE_CONSENT_KEYS, QeSignatureConfig, type ElectronicSignatureDocument as QeSignatureDocument, QeSignatureManager, type ElectronicSignatureState as QeSignatureState, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };

package/dist/qe-signature.esm.js

@@ -0,0 +1,8 @@
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./xstate.esm-B70JrNqo.esm.js";
+import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+import { t as createQeSignatureManager } from "./qe-signature-DFo_Cc-I.esm.js";
+
+export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };