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

package/dist/permissionServices-CVR0Pq38.esm.js

@@ -0,0 +1,72 @@
+import { h as stopCameraStream, m as requestCameraAccess, p as queryCameraPermission } from "./endpoints-D_pUMaqA.esm.js";
+
+//#region ../infra/src/device/getBrowser.ts
+function getUserAgent() {
+	if (typeof navigator === "undefined") return "";
+	return navigator.userAgent;
+}
+
+//#endregion
+//#region ../infra/src/device/getDeviceClass.ts
+function getDeviceInfo() {
+	if (typeof navigator === "undefined") return {
+		userAgent: "",
+		platform: "",
+		maxTouchPoints: 0
+	};
+	return {
+		userAgent: navigator.userAgent,
+		platform: navigator.platform,
+		maxTouchPoints: navigator.maxTouchPoints
+	};
+}
+
+//#endregion
+//#region src/device/getBrowser.ts
+function getBrowser() {
+	const userAgent = getUserAgent();
+	if (!userAgent) return "other";
+	const ua = userAgent.toLowerCase();
+	if (ua.includes("edg/")) return "edge";
+	if (ua.includes("chrome") && !ua.includes("edg/")) return "chrome";
+	if (ua.includes("firefox")) return "firefox";
+	if (ua.includes("safari") && !ua.includes("chrome")) return "safari";
+	return "other";
+}
+
+//#endregion
+//#region src/device/getDeviceClass.ts
+function getDeviceClass() {
+	const { userAgent, platform, maxTouchPoints } = getDeviceInfo();
+	if (!userAgent) return "desktop";
+	const ua = userAgent.toLowerCase();
+	if (/iphone|ipad|ipod/.test(ua) || platform === "MacIntel" && maxTouchPoints > 1) return "ios";
+	if (/android/.test(ua)) return "android";
+	return "desktop";
+}
+
+//#endregion
+//#region src/permissions/permissionServices.ts
+/**
+* Checks the current camera permission state without prompting the user.
+*/
+async function checkPermission() {
+	return queryCameraPermission();
+}
+/**
+* Requests camera permission by attempting to access the camera, then immediately
+* stops the obtained stream. This function does not keep or return the stream.
+*/
+async function requestPermission() {
+	try {
+		stopCameraStream(await requestCameraAccess({ video: true }));
+		return "granted";
+	} catch (error) {
+		const name = error instanceof Error ? error.name : void 0;
+		if (name === "NotAllowedError" || name === "PermissionDeniedError") return "denied";
+		return "prompt";
+	}
+}
+
+//#endregion
+export { getBrowser as i, requestPermission as n, getDeviceClass as r, checkPermission as t };

package/dist/phone.d.ts

@@ -0,0 +1,292 @@
+import { t as Manager } from "./Manager-6BwbaI_H.js";
+
+//#region src/phone/types.d.ts
+
+/**
+ * Configuration options for phone verification.
+ *
+ * @example Standard OTP verification
+ * ```typescript
+ * const config: PhoneConfig = {
+ *   otpVerification: true,
+ *   otpExpirationInMinutes: 5,
+ *   prefill: false,
+ * };
+ * ```
+ *
+ * @example With all options
+ * ```typescript
+ * const config: PhoneConfig = {
+ *   otpVerification: true,
+ *   otpExpirationInMinutes: 10,
+ *   prefill: true,
+ *   isInstantVerify: false,
+ *   optinEnabled: true,
+ *   maxOtpAttempts: 3,
+ * };
+ * ```
+ */
+type PhoneConfig = {
+  /**
+   * Whether to require OTP (SMS code) verification.
+   * If false, phone is verified immediately after submission.
+   */
+  otpVerification: boolean;
+  /**
+   * How long the OTP code remains valid, in minutes.
+   * After expiration, user must request a new code.
+   */
+  otpExpirationInMinutes: number;
+  /**
+   * Whether to pre-populate with user's previously stored phone number.
+   * Useful for returning users.
+   */
+  prefill: boolean;
+  /**
+   * Use carrier-based instant verification instead of OTP.
+   * Not available in all regions.
+   * @default false
+   */
+  isInstantVerify?: boolean;
+  /**
+   * Show a marketing opt-in checkbox in the UI.
+   * User's preference is sent with the phone submission.
+   * @default false
+   */
+  optinEnabled?: boolean;
+  /**
+   * Maximum number of OTP verification attempts before lockout.
+   * After exhausting attempts, user sees an error state.
+   * @default 3
+   */
+  maxOtpAttempts?: number;
+};
+//#endregion
+//#region src/phone/phoneStateMachine.d.ts
+
+declare const phoneMachine: any;
+//#endregion
+//#region src/phone/phoneActor.d.ts
+type CreatePhoneActorOptions = {
+  config: PhoneConfig;
+};
+//#endregion
+//#region src/phone/phoneManager.d.ts
+/** Phone manager is in initial state, waiting for `load()` to be called */
+type PhoneIdleState = {
+  status: 'idle';
+};
+/** Loading prefilled phone number from backend (if prefill is enabled) */
+type PhoneLoadingPrefillState = {
+  status: 'loadingPrefill';
+};
+/**
+ * Ready for phone input - use `setPhoneNumber()` and `submit()`
+ * @property countryCode - ISO country code (e.g., 'US', 'MX')
+ * @property phonePrefix - International dialing prefix (e.g., '+1', '+52')
+ * @property prefilledPhone - Pre-populated phone number (if prefill enabled)
+ * @property phoneError - Validation error message if phone was rejected
+ */
+type PhoneInputtingState = {
+  status: 'inputting';
+  countryCode: string;
+  phonePrefix: string;
+  prefilledPhone?: string;
+  phoneError?: string;
+};
+/** Phone number is being submitted to the backend */
+type PhoneSubmittingState = {
+  status: 'submitting';
+};
+/** OTP is being sent to the phone number */
+type PhoneSendingOtpState = {
+  status: 'sendingOtp';
+};
+/**
+ * Waiting for OTP code - use `submitOtp()`, `resendOtp()`, or `back()`
+ * @property resendTimer - Seconds remaining before resend is allowed
+ * @property canResend - Whether the resend button should be enabled
+ * @property attemptsRemaining - Number of OTP verification attempts left
+ */
+type PhoneAwaitingOtpState = {
+  status: 'awaitingOtp';
+  resendTimer: number;
+  canResend: boolean;
+  attemptsRemaining: number;
+};
+/** OTP code is being verified against the backend */
+type PhoneVerifyingOtpState = {
+  status: 'verifyingOtp';
+};
+/**
+ * OTP verification failed - user can retry with `submitOtp()`
+ * @property error - Error message describing why verification failed
+ * @property attemptsRemaining - Number of remaining attempts before lockout
+ */
+type PhoneOtpErrorState = {
+  status: 'otpError';
+  error: string;
+  attemptsRemaining: number;
+};
+/** Phone verification completed successfully - call `reset()` to start over */
+type PhoneSuccessState = {
+  status: 'success';
+};
+/**
+ * Fatal error occurred - call `reset()` to start over
+ * @property error - Error message describing what went wrong
+ */
+type PhoneErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible phone manager states.
+ * Use discriminated union pattern to narrow the type:
+ *
+ * @example
+ * ```typescript
+ * const state = phoneManager.getState();
+ * if (state.status === 'inputting') {
+ *   // TypeScript knows state has countryCode, phonePrefix, etc.
+ *   console.log(state.countryCode);
+ * }
+ * ```
+ */
+type PhoneState = PhoneIdleState | PhoneLoadingPrefillState | PhoneInputtingState | PhoneSubmittingState | PhoneSendingOtpState | PhoneAwaitingOtpState | PhoneVerifyingOtpState | PhoneOtpErrorState | PhoneSuccessState | PhoneErrorState;
+/**
+ * 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)} />;
+ * }
+ * ```
+ */
+declare function createPhoneManager(options: CreatePhoneActorOptions): Manager<PhoneState> & {
+  /**
+   * Initializes the phone verification flow.
+   * Transitions from 'idle' to 'loadingPrefill' or 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Sets the phone number for verification.
+   * Should be called when state is 'inputting'.
+   *
+   * @param phone - Full phone number with country code (e.g., '+14155551234')
+   * @param isValid - Whether the phone number passes validation
+   *
+   * @example
+   * ```typescript
+   * // Using libphonenumber-js for validation
+   * import { isValidPhoneNumber } from 'libphonenumber-js';
+   * const phone = '+14155551234';
+   * phoneManager.setPhoneNumber(phone, isValidPhoneNumber(phone));
+   * ```
+   */
+  setPhoneNumber(phone: string, isValid: boolean): void;
+  /**
+   * Sets the marketing opt-in preference.
+   * Only relevant if `config.optinEnabled` is true.
+   *
+   * @param granted - Whether the user consented to receive marketing messages
+   */
+  setOptInGranted(granted: boolean): void;
+  /**
+   * Submits the phone number for verification.
+   * Requires a valid phone number to be set via `setPhoneNumber()`.
+   * Transitions to 'submitting', then to 'sendingOtp' or 'success' (if no OTP).
+   */
+  submit(): void;
+  /**
+   * Sets the OTP code without submitting.
+   * Use this for controlled input components.
+   *
+   * @param code - The OTP code entered by the user
+   */
+  setOtpCode(code: string): void;
+  /**
+   * Sets and submits the OTP code in one call.
+   * Should be called when state is 'awaitingOtp' or 'otpError'.
+   *
+   * @param code - The complete OTP code (typically 6 alphanumeric characters)
+   *
+   * @example
+   * ```typescript
+   * // Submit OTP when user completes entry
+   * phoneManager.submitOtp('HH36LP');
+   * ```
+   */
+  submitOtp(code: string): void;
+  /**
+   * Requests a new OTP code to be sent.
+   * Only works when state is 'awaitingOtp' and `canResend` is true.
+   * Resets the resend timer.
+   */
+  resendOtp(): void;
+  /**
+   * Returns to the phone input screen from OTP entry.
+   * Allows the user to change their phone number.
+   * Transitions from 'awaitingOtp' or 'otpError' back to 'inputting'.
+   */
+  back(): void;
+  /**
+   * Resets the manager to initial state.
+   * Can be called from 'success' or 'error' states to start over.
+   * Clears all stored data including phone number and OTP.
+   */
+  reset(): void;
+};
+/**
+ * Type representing a phone manager instance.
+ * Includes state access, API methods, and lifecycle management.
+ *
+ * @property getState - Returns the current PhoneState
+ * @property subscribe - Subscribes to state changes, returns unsubscribe function
+ * @property stop - Stops the manager and cleans up resources
+ * @property load - Initializes the verification flow
+ * @property setPhoneNumber - Sets the phone number
+ * @property setOptInGranted - Sets marketing opt-in preference
+ * @property submit - Submits the phone number
+ * @property setOtpCode - Sets OTP code without submitting
+ * @property submitOtp - Sets and submits OTP code
+ * @property resendOtp - Requests new OTP code
+ * @property back - Returns to phone input from OTP screen
+ * @property reset - Resets to initial state
+ */
+type PhoneManager = ReturnType<typeof createPhoneManager>;
+//#endregion
+export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };