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

package/dist/phone.esm.js

@@ -1,550 +1,9 @@
-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";
+import "./BrowserTimerProvider-DhNc_x02.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./xstate.esm-B70JrNqo.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-CuPARRaT.esm.js";
+import { t as createPhoneManager } from "./phoneManager-DAJbGhlY.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 };