@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/email.esm.js

@@ -0,0 +1,479 @@
+import { g as createManager, n as api, t as endpoints } from "./endpoints-D_pUMaqA.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
+import { t as addEvent } from "./addEvent-1Mi5CEiq.esm.js";
+
+//#region src/email/emailServices.ts
+async function fetchEmail(signal) {
+	const res = await api.get(endpoints.getEmail, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getEmail} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addEmail(params, signal) {
+	const res = await api.post(endpoints.email, { email: params.email }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.email} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function sendEmailOtp(signal) {
+	const res = await api.get(`${endpoints.sendSmsOtp}?communicationchannel=EMAIL`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.sendSmsOtp} failed: ${res.status} ${res.statusText}`);
+}
+async function verifyEmailOtp(code, signal) {
+	const res = await api.get(`${endpoints.compareOtp}?code=${code}&channel=EMAIL`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.compareOtp} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/email/emailStateMachine.ts
+const RESEND_TIMER_SECONDS = 30;
+const emailMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchEmail: fromPromise(async ({ signal }) => {
+			return fetchEmail(signal);
+		}),
+		submitEmail: fromPromise(async ({ input, signal }) => {
+			return addEmail({ email: input.email }, signal);
+		}),
+		sendOtp: fromPromise(async ({ signal }) => {
+			return sendEmailOtp(signal);
+		}),
+		verifyOtp: fromPromise(async ({ input, signal }) => {
+			return verifyEmailOtp(input.code, signal);
+		}),
+		resendTimer: fromCallback(({ sendBack }) => {
+			let seconds = RESEND_TIMER_SECONDS;
+			const interval = setInterval(() => {
+				seconds -= 1;
+				sendBack({ type: "TICK" });
+				if (seconds <= 0) clearInterval(interval);
+			}, 1e3);
+			return () => clearInterval(interval);
+		})
+	},
+	actions: {
+		setPrefilledEmail: assign(({ event }) => {
+			const email = event.output.email;
+			return {
+				prefilledEmail: email,
+				email
+			};
+		}),
+		setEmail: assign(({ event }) => {
+			const e = event;
+			return {
+				email: e.email,
+				isValid: e.isValid,
+				emailError: e.isValid ? void 0 : "Invalid email address"
+			};
+		}),
+		setEmailError: assign(({ event }) => ({ emailError: String(event.error) })),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		clearEmailError: assign({ emailError: () => void 0 }),
+		setOtpCode: assign(({ event }) => ({
+			otpCode: event.code,
+			otpError: void 0
+		})),
+		setOtpError: assign(({ context, event }) => ({
+			otpError: String(event.error),
+			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
+			};
+		}),
+		stopResendTimer: assign({ resendTimerActive: () => false }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			email: "",
+			isValid: false,
+			emailError: void 0,
+			prefilledEmail: void 0,
+			error: void 0,
+			otpCode: "",
+			otpError: void 0,
+			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
+			resendTimer: 0,
+			resendTimerActive: false
+		})),
+		sendEmailSubmitEvent: () => {
+			addEvent({
+				code: "continue",
+				module: "email",
+				screen: "emailInput"
+			});
+		}
+	},
+	guards: {
+		hasPrefill: ({ context }) => context.config.prefill,
+		hasOtpVerification: ({ context }) => context.config.otpVerification,
+		isValidEmail: ({ context }) => context.isValid,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		canResend: ({ context }) => !context.resendTimerActive
+	}
+}).createMachine({
+	id: "email",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		email: "",
+		isValid: false,
+		emailError: void 0,
+		prefilledEmail: 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: "inputting" }] } },
+		loadingPrefill: { invoke: {
+			id: "fetchEmail",
+			src: "fetchEmail",
+			onDone: {
+				target: "inputting",
+				actions: "setPrefilledEmail"
+			},
+			onError: { target: "inputting" }
+		} },
+		inputting: {
+			entry: "clearEmailError",
+			on: {
+				EMAIL_CHANGED: { actions: "setEmail" },
+				SUBMIT: {
+					target: "submitting",
+					guard: "isValidEmail"
+				}
+			}
+		},
+		submitting: { invoke: {
+			id: "submitEmail",
+			src: "submitEmail",
+			input: ({ context }) => ({ email: context.email }),
+			onDone: [{
+				target: "sendingOtp",
+				guard: "hasOtpVerification",
+				actions: "sendEmailSubmitEvent"
+			}, {
+				target: "success",
+				actions: "sendEmailSubmitEvent"
+			}],
+			onError: {
+				target: "inputting",
+				actions: "setEmailError"
+			}
+		} },
+		sendingOtp: { invoke: {
+			id: "sendOtp",
+			src: "sendOtp",
+			onDone: { target: "awaitingOtp" },
+			onError: {
+				target: "awaitingOtp",
+				actions: "setError"
+			}
+		} },
+		awaitingOtp: {
+			entry: "startResendTimer",
+			invoke: {
+				id: "resendTimer",
+				src: "resendTimer"
+			},
+			on: {
+				TICK: { actions: "tickResendTimer" },
+				OTP_CHANGED: { actions: "setOtpCode" },
+				VERIFY_OTP: { target: "verifyingOtp" },
+				RESEND_OTP: {
+					target: "sendingOtp",
+					guard: "canResend"
+				},
+				BACK: { target: "inputting" }
+			}
+		},
+		verifyingOtp: { invoke: {
+			id: "verifyOtp",
+			src: "verifyOtp",
+			input: ({ context }) => ({ code: context.otpCode }),
+			onDone: [
+				{
+					target: "success",
+					guard: ({ event }) => event.output.success === true
+				},
+				{
+					target: "otpError",
+					guard: "hasAttemptsRemaining",
+					actions: assign(({ context }) => ({
+						otpError: "Invalid OTP code",
+						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: { on: {
+			OTP_CHANGED: {
+				target: "awaitingOtp",
+				actions: "setOtpCode"
+			},
+			RESEND_OTP: {
+				target: "sendingOtp",
+				guard: "canResend"
+			},
+			BACK: { target: "inputting" }
+		} },
+		success: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/email/emailActor.ts
+function createEmailActor(options) {
+	return createActor(emailMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/email/emailManager.ts
+/**
+* @module @incodetech/core/email
+*
+* Email verification module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The email manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless email verification with OTP
+* ```typescript
+* import { createEmailManager } from '@incodetech/core/email';
+* import { setup } from '@incodetech/core';
+*
+* // 1. Configure the SDK (required before using any module)
+* setup({ apiURL: 'https://api.example.com', token: 'your-token' });
+*
+* // 2. Create the email manager
+* const emailManager = createEmailManager({
+*   config: {
+*     otpVerification: true,
+*     otpExpirationInMinutes: 5,
+*     prefill: false,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* emailManager.subscribe((state) => {
+*   console.log('Email state:', state.status);
+*   if (state.status === 'success') {
+*     console.log('Email verified successfully!');
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* emailManager.load();
+*
+* // 5. When state is 'inputting', set the email address
+* emailManager.setEmail('user@example.com', true);
+*
+* // 6. Submit the email address
+* emailManager.submit();
+*
+* // 7. When state is 'awaitingOtp', submit the OTP code
+* emailManager.submitOtp('ABC123');
+*
+* // 8. Clean up when done
+* emailManager.stop();
+* ```
+*
+* @example Polling-based headless usage
+* ```typescript
+* const emailManager = createEmailManager({ config });
+*
+* emailManager.load();
+*
+* // Poll for state changes
+* const interval = setInterval(() => {
+*   const state = emailManager.getState();
+*
+*   switch (state.status) {
+*     case 'inputting':
+*       emailManager.setEmail('user@example.com', true);
+*       emailManager.submit();
+*       break;
+*     case 'awaitingOtp':
+*       // Get OTP from user or external source
+*       emailManager.submitOtp(otpCode);
+*       break;
+*     case 'success':
+*       clearInterval(interval);
+*       emailManager.stop();
+*       break;
+*     case 'error':
+*       clearInterval(interval);
+*       console.error(state.error);
+*       emailManager.stop();
+*       break;
+*   }
+* }, 100);
+* ```
+*/
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loadingPrefill")) return { status: "loadingPrefill" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		prefilledEmail: context.prefilledEmail,
+		emailError: context.emailError
+	};
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("sendingOtp")) return { status: "sendingOtp" };
+	if (typedSnapshot.matches("awaitingOtp")) return {
+		status: "awaitingOtp",
+		resendTimer: context.resendTimer,
+		canResend: !context.resendTimerActive,
+		attemptsRemaining: context.attemptsRemaining
+	};
+	if (typedSnapshot.matches("verifyingOtp")) return { status: "verifyingOtp" };
+	if (typedSnapshot.matches("otpError")) return {
+		status: "otpError",
+		error: context.otpError ?? "Invalid OTP code",
+		attemptsRemaining: context.attemptsRemaining
+	};
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setEmail(email, isValid) {
+			actor.send({
+				type: "EMAIL_CHANGED",
+				email,
+				isValid
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		},
+		setOtpCode(code) {
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+		},
+		submitOtp(code) {
+			actor.send({
+				type: "OTP_CHANGED",
+				code
+			});
+			actor.send({ type: "VERIFY_OTP" });
+		},
+		resendOtp() {
+			actor.send({ type: "RESEND_OTP" });
+		},
+		back() {
+			actor.send({ type: "BACK" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates an email verification manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for email address verification
+* with optional OTP (one-time password) verification.
+*
+* @param options - Configuration options
+* @param options.config - Email verification configuration
+* @param options.config.otpVerification - Whether to require OTP verification
+* @param options.config.otpExpirationInMinutes - How long the OTP is valid
+* @param options.config.prefill - Whether to fetch a pre-filled email address
+* @param options.config.maxOtpAttempts - Maximum OTP verification attempts (default: 3)
+*
+* @returns Email manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createEmailManager({
+*   config: { otpVerification: true, otpExpirationInMinutes: 5, prefill: false },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setEmail('user@example.com', true);
+* manager.submit();
+* // ... wait for 'awaitingOtp' state ...
+* manager.submitOtp('ABC123');
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createEmailManager({ config }));
+*
+* if (state.status === 'inputting') {
+*   return <input onChange={(e) => manager.setEmail(e.target.value, true)} />;
+* }
+* ```
+*/
+function createEmailManager(options) {
+	return createManager({
+		actor: createEmailActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createEmailManager, emailMachine };