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

package/dist/phone.esm.js

@@ -0,0 +1,550 @@
+import { g as createManager, n as api, t as endpoints } from "./endpoints-BSTFaHYo.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-W0ORK0jT.esm.js";
+
+//#region src/modules/phone/phoneServices.ts
+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) {
+	const res = await api.post(endpoints.phone, {
+		phone: params.phone,
+		optInGranted: params.optInGranted
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.phone} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addPhoneInstantVerify(params, signal) {
+	const res = await api.post(endpoints.phoneInstant, {
+		phone: params.phone,
+		optInGranted: params.optInGranted
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.phoneInstant} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function sendOtp(signal) {
+	const res = await api.get(`${endpoints.sendSmsOtp}?communicationchannel=SMS`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.sendSmsOtp} failed: ${res.status} ${res.statusText}`);
+}
+async function verifyOtp(code, signal) {
+	const res = await api.get(`${endpoints.compareOtp}?code=${code}&channel=SMS`, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.compareOtp} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/phone/phoneStateMachine.ts
+const RESEND_TIMER_SECONDS = 30;
+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(({ sendBack }) => {
+			let seconds = RESEND_TIMER_SECONDS;
+			const interval = setInterval(() => {
+				seconds -= 1;
+				sendBack({ type: "TICK" });
+				if (seconds <= 0) clearInterval(interval);
+			}, 1e3);
+			return () => 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: e.isValid ? void 0 : "Invalid phone number"
+			};
+		}),
+		setPhoneError: assign(({ event }) => ({ phoneError: String(event.error) })),
+		setOptInGranted: assign(({ event }) => ({ optInGranted: event.granted })),
+		setError: assign(({ event }) => ({ error: String(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: 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,
+			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
+		})),
+		sendPhoneSubmitEvent: () => {
+			addEvent({
+				code: "continue",
+				module: "phone",
+				screen: "phoneInput"
+			});
+		}
+	},
+	guards: {
+		hasPrefill: ({ context }) => context.config.prefill,
+		hasOtpVerification: ({ context }) => context.config.otpVerification,
+		isValidPhone: ({ context }) => context.isValid,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		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: {
+			entry: "clearPhoneError",
+			on: {
+				PHONE_CHANGED: { actions: "setPhone" },
+				OPT_IN_CHANGED: { actions: "setOptInGranted" },
+				SUBMIT: {
+					target: "submitting",
+					guard: "isValidPhone"
+				}
+			}
+		},
+		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: "sendingOtp",
+				guard: "hasOtpVerification",
+				actions: "sendPhoneSubmitEvent"
+			}, {
+				target: "success",
+				actions: "sendPhoneSubmitEvent"
+			}],
+			onError: {
+				target: "inputting",
+				actions: "setPhoneError"
+			}
+		} },
+		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: { type: "final" },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/modules/phone/phoneActor.ts
+function createPhoneActor(options) {
+	return createActor(phoneMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/phone/phoneManager.ts
+/**
+* @module @incodetech/core/phone
+*
+* Phone verification module for the Incode Web SDK.
+* Supports both headless (programmatic) and UI-driven usage patterns.
+*
+* ## Headless Usage
+*
+* The phone manager can be used entirely without UI for backend integrations,
+* custom UI implementations, or automated workflows.
+*
+* @example Basic headless phone verification with OTP
+* ```typescript
+* import { createPhoneManager } from '@incodetech/core/phone';
+* 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 phone manager
+* const phoneManager = createPhoneManager({
+*   config: {
+*     otpVerification: true,
+*     otpExpirationInMinutes: 5,
+*     prefill: false,
+*     maxOtpAttempts: 3,
+*   },
+* });
+*
+* // 3. Subscribe to state changes (optional but recommended)
+* phoneManager.subscribe((state) => {
+*   console.log('Phone state:', state.status);
+*   if (state.status === 'success') {
+*     console.log('Phone verified successfully!');
+*   }
+*   if (state.status === 'error') {
+*     console.error('Error:', state.error);
+*   }
+* });
+*
+* // 4. Start the flow
+* phoneManager.load();
+*
+* // 5. When state is 'inputting', set the phone number
+* phoneManager.setPhoneNumber('+14155551234', true);
+*
+* // 6. Submit the phone number
+* phoneManager.submit();
+*
+* // 7. When state is 'awaitingOtp', submit the OTP code
+* phoneManager.submitOtp('ABC123');
+*
+* // 8. Clean up when done
+* phoneManager.stop();
+* ```
+*
+* @example Polling-based headless usage
+* ```typescript
+* const phoneManager = createPhoneManager({ config });
+*
+* phoneManager.load();
+*
+* // Poll for state changes
+* const interval = setInterval(() => {
+*   const state = phoneManager.getState();
+*
+*   switch (state.status) {
+*     case 'inputting':
+*       phoneManager.setPhoneNumber('+14155551234', true);
+*       phoneManager.submit();
+*       break;
+*     case 'awaitingOtp':
+*       // Get OTP from user or external source
+*       phoneManager.submitOtp(otpCode);
+*       break;
+*     case 'success':
+*       clearInterval(interval);
+*       phoneManager.stop();
+*       break;
+*     case 'error':
+*       clearInterval(interval);
+*       console.error(state.error);
+*       phoneManager.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("loadingStartInfo")) return {
+		status: "inputting",
+		countryCode: context.countryCode,
+		phonePrefix: context.phonePrefix,
+		prefilledPhone: context.prefilledPhone
+	};
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		countryCode: context.countryCode,
+		phonePrefix: context.phonePrefix,
+		prefilledPhone: context.prefilledPhone,
+		phoneError: context.phoneError
+	};
+	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" });
+		},
+		setPhoneNumber(phone, isValid) {
+			actor.send({
+				type: "PHONE_CHANGED",
+				phone,
+				isValid
+			});
+		},
+		setOptInGranted(granted) {
+			actor.send({
+				type: "OPT_IN_CHANGED",
+				granted
+			});
+		},
+		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 a phone verification manager for headless or UI-driven usage.
+*
+* The manager provides a state machine-based API for phone number verification
+* with optional OTP (one-time password) verification.
+*
+* @param options - Configuration options
+* @param options.config - Phone 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 phone number
+* @param options.config.isInstantVerify - Use instant verification API
+* @param options.config.optinEnabled - Show marketing opt-in checkbox
+* @param options.config.maxOtpAttempts - Maximum OTP verification attempts (default: 3)
+*
+* @returns Phone manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createPhoneManager({
+*   config: { otpVerification: true, otpExpirationInMinutes: 5, prefill: false },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setPhoneNumber('+14155551234', true);
+* manager.submit();
+* // ... wait for 'awaitingOtp' state ...
+* manager.submitOtp('ABC123');
+* manager.stop();
+* ```
+*
+* @example With React/Preact UI hook
+* ```tsx
+* const [state, manager] = useManager(() => createPhoneManager({ config }));
+*
+* if (state.status === 'inputting') {
+*   return <input onChange={(e) => manager.setPhoneNumber(e.target.value, true)} />;
+* }
+* ```
+*/
+function createPhoneManager(options) {
+	return createManager({
+		actor: createPhoneActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createPhoneManager, phoneMachine };