@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/phoneStateMachine-CuPARRaT.esm.js

@@ -1,351 +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/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

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

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

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

@@ -1,8 +0,0 @@
-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 };