@thunderid/react 1.5.0 → 1.7.0

package/dist/components/auth/SignIn/SignIn.js

@@ -0,0 +1,662 @@
+import useThunderID_default from "../../../contexts/ThunderID/useThunderID.js";
+import useTranslation_default from "../../../hooks/useTranslation.js";
+import { extractErrorMessage, normalizeFlowResponse } from "../../../utils/flowTransformer.js";
+import BaseSignIn_default from "./BaseSignIn.js";
+import { useOAuthCallback } from "../../../hooks/auth/useOAuthCallback.js";
+import { initiateOAuthRedirect } from "../../../utils/oauth.js";
+import { handlePasskeyAuthentication, handlePasskeyRegistration } from "../../../utils/passkey.js";
+import { ConsentConstants, EmbeddedFlowType, EmbeddedSignInFlowStatus, EmbeddedSignInFlowType, ThunderIDAPIError, ThunderIDRuntimeError, logger } from "@thunderid/browser";
+import { useEffect, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+
+//#region src/components/auth/SignIn/SignIn.tsx
+/**
+* Sentinel input key carrying the reason a consent prompt was submitted. It is folded into the
+* compiled `consent_decisions` payload and stripped from the inputs, like `__consent_opt__` keys.
+*/
+const CONSENT_REASON_KEY = "__consent_reason__";
+/** Flattens a component tree into a single list, parents before their children. */
+const flattenComponents = (comps) => (comps ?? []).flatMap((comp) => [comp, ...flattenComponents(comp.components)]);
+/**
+* Finds the action to submit an expired consent prompt with. A non-primary submit action is
+* preferred so the payload reads as a denial, falling back to any submit action because the server
+* needs an action to route the prompt node. Returns undefined when the view has neither.
+*/
+const findConsentSubmitActionId = (comps) => {
+	const submitActions = flattenComponents(comps).filter((comp) => comp.id && comp.eventType?.toUpperCase() === "SUBMIT");
+	return (submitActions.find((comp) => comp.variant?.toLowerCase() !== "primary") ?? submitActions[0])?.id;
+};
+/**
+* A component-driven SignIn component that provides authentication flow with pre-built styling.
+* This component handles the flow API calls for authentication and delegates UI logic to BaseSignIn.
+* It automatically transforms simple input-based responses into component-driven UI format.
+*
+* @example
+* // Default UI
+* ```tsx
+* import { SignIn } from '@thunderid/react/component-driven';
+*
+* const App = () => {
+*   return (
+*     <SignIn
+*       onSuccess={(authData) => {
+*         console.log('Authentication successful:', authData);
+*       }}
+*       onError={(error) => {
+*         console.error('Authentication failed:', error);
+*       }}
+*       size="medium"
+*       variant="outlined"
+*     />
+*   );
+* };
+* ```
+*
+* @example
+* // Custom UI with render props
+* ```tsx
+* import { SignIn } from '@thunderid/react/component-driven';
+*
+* const App = () => {
+*   return (
+*     <SignIn
+*       onSuccess={(authData) => console.log('Success:', authData)}
+*       onError={(error) => console.error('Error:', error)}
+*     >
+*       {({signIn, isLoading, components, error, isInitialized}) => (
+*         <div className="custom-signin">
+*           <h1>Custom Sign In</h1>
+*           {!isInitialized ? (
+*             <p>Initializing...</p>
+*           ) : error ? (
+*             <div className="error">{error.message}</div>
+*           ) : (
+*             <form onSubmit={(e) => {
+*               e.preventDefault();
+*               signIn({inputs: {username: 'user', password: 'pass'}});
+*             }}>
+*               <button type="submit" disabled={isLoading}>
+*                 {isLoading ? 'Signing in...' : 'Sign In'}
+*               </button>
+*             </form>
+*           )}
+*         </div>
+*       )}
+*     </SignIn>
+*   );
+* };
+* ```
+*/
+const SignIn = ({ className, preferences, size = "medium", onSuccess, onError, variant, children, revalidateOnChangeAfterBlur }) => {
+	const { applicationId, afterSignInUrl, signIn, isInitialized, isLoading, meta, getStorageManager, scopes, vendor } = useThunderID_default();
+	const { t } = useTranslation_default(preferences?.i18n);
+	const [components, setComponents] = useState([]);
+	const [additionalData, setAdditionalData] = useState({});
+	const [serverFieldErrors, setServerFieldErrors] = useState(null);
+	const [currentExecutionId, setCurrentExecutionId] = useState(null);
+	const challengeTokenRef = useRef(null);
+	const [isStorageReady, setIsStorageReady] = useState(false);
+	const [isFlowInitialized, setIsFlowInitialized] = useState(false);
+	const [flowError, setFlowError] = useState(null);
+	const [isSubmitting, setIsSubmitting] = useState(false);
+	const [isTimeoutDisabled, setIsTimeoutDisabled] = useState(false);
+	const [passkeyState, setPasskeyState] = useState({
+		actionId: null,
+		challenge: null,
+		creationOptions: null,
+		error: null,
+		executionId: null,
+		isActive: false
+	});
+	const initializationAttemptedRef = useRef(false);
+	const oauthCodeProcessedRef = useRef(false);
+	const passkeyProcessedRef = useRef(false);
+	const timeoutSubmittedForRef = useRef(null);
+	const timeoutContextRef = useRef(null);
+	/**
+	* Sets executionId between sessionStorage and state.
+	* This ensures both are always in sync.
+	*/
+	const setExecutionId = (executionId) => {
+		setCurrentExecutionId(executionId);
+		if (executionId) sessionStorage.setItem(`${vendor}_execution_id`, executionId);
+		else sessionStorage.removeItem(`${vendor}_execution_id`);
+	};
+	/**
+	* Restore any challenge token persisted before an OAuth redirect.
+	* Waits for SDK initialization before reading from storage.
+	*/
+	useEffect(() => {
+		if (!isInitialized) return;
+		(async () => {
+			try {
+				const tempData = await (await getStorageManager())?.getTemporaryData();
+				if (tempData?.challengeToken) challengeTokenRef.current = tempData.challengeToken;
+			} finally {
+				setIsStorageReady(true);
+			}
+		})();
+	}, [isInitialized]);
+	/**
+	* Updates challengeTokenRef immediately (stale-closure safe) and persists via
+	* the provider's StorageManager so the token survives OAuth redirects.
+	*/
+	const setChallengeToken = async (challengeToken) => {
+		challengeTokenRef.current = challengeToken;
+		try {
+			const storageManager = await getStorageManager();
+			if (storageManager) if (challengeToken) await storageManager.setTemporaryDataParameter("challengeToken", challengeToken);
+			else await storageManager.removeTemporaryDataParameter("challengeToken");
+		} catch {
+			logger.warn("Failed to persist challenge token in storage.");
+		}
+	};
+	/**
+	* Clear all flow-related storage and state.
+	*/
+	const clearFlowState = async () => {
+		setExecutionId(null);
+		setComponents([]);
+		setAdditionalData({});
+		setIsFlowInitialized(false);
+		await setChallengeToken(null);
+		try {
+			await (await getStorageManager())?.removeHybridDataParameter?.("authId");
+		} catch {
+			logger.warn("Failed to clear authId from hybrid storage.");
+		}
+		setIsTimeoutDisabled(false);
+		oauthCodeProcessedRef.current = false;
+	};
+	/**
+	* Parse URL parameters used in flows.
+	*/
+	const getUrlParams = () => {
+		const urlParams = new URL(window?.location?.href ?? "").searchParams;
+		return {
+			applicationId: urlParams.get("applicationId"),
+			authId: urlParams.get("authId"),
+			code: urlParams.get("code"),
+			error: urlParams.get("error"),
+			errorDescription: urlParams.get("error_description"),
+			executionId: urlParams.get("executionId"),
+			nonce: urlParams.get("nonce"),
+			state: urlParams.get("state")
+		};
+	};
+	/**
+	* Handle authId from URL and persist it via the storage manager so it survives URL cleanup.
+	* ThunderIDReactClient.signIn() reads authId from storageManager.getHybridDataParameter('authId'),
+	* not from raw sessionStorage, so we must use the same storage path here.
+	*/
+	const handleAuthId = async (authId) => {
+		if (authId) try {
+			await (await getStorageManager())?.setHybridDataParameter?.("authId", authId);
+		} catch {
+			logger.warn("Failed to store authId in hybrid storage.");
+		}
+	};
+	/**
+	* Clean up OAuth-related URL parameters from the browser URL.
+	*/
+	const cleanupOAuthUrlParams = (includeNonce = false) => {
+		if (!window?.location?.href) return;
+		const url = new URL(window.location.href);
+		url.searchParams.delete("error");
+		url.searchParams.delete("error_description");
+		url.searchParams.delete("code");
+		url.searchParams.delete("state");
+		if (includeNonce) url.searchParams.delete("nonce");
+		window?.history?.replaceState({}, "", url.toString());
+	};
+	/**
+	* Clean up flow-related URL parameters (executionId, authId) from the browser URL.
+	* Used after executionId is set in state to prevent using invalidated executionId from URL.
+	*/
+	const cleanupFlowUrlParams = () => {
+		if (!window?.location?.href) return;
+		const url = new URL(window.location.href);
+		url.searchParams.delete("executionId");
+		url.searchParams.delete("authId");
+		url.searchParams.delete("applicationId");
+		window?.history?.replaceState({}, "", url.toString());
+	};
+	/**
+	* Set error state and call onError callback.
+	* Ensures isFlowInitialized is true so errors can be displayed in the UI.
+	*/
+	const setError = (error) => {
+		setFlowError(error);
+		setIsFlowInitialized(true);
+		onError?.(error);
+	};
+	/**
+	* Handle OAuth error from URL parameters.
+	* Clears flow state, creates error, and cleans up URL.
+	*/
+	const handleOAuthError = (error, errorDescription) => {
+		clearFlowState();
+		setError(new ThunderIDRuntimeError(errorDescription || `OAuth error: ${error}`, "SIGN_IN_ERROR", "react"));
+		cleanupOAuthUrlParams(true);
+	};
+	/**
+	* Handle REDIRECTION response by storing flow state and redirecting to OAuth provider.
+	*/
+	const handleRedirection = async (response) => {
+		if (response.type === EmbeddedSignInFlowType.Redirection) {
+			const redirectURL = response.data?.redirectURL || response?.redirectURL;
+			if (redirectURL && window?.location) {
+				if (response.executionId) setExecutionId(response.executionId);
+				await setChallengeToken(response.challengeToken ?? null);
+				await handleAuthId(getUrlParams().authId);
+				initiateOAuthRedirect(redirectURL, vendor);
+				return true;
+			}
+		}
+		return false;
+	};
+	/**
+	* Handle ERROR and COMPLETE responses. Returns true if fully handled.
+	* ERROR + executionId: recoverable — session preserved for retry.
+	* ERROR + no executionId: terminal — clear state and surface the error.
+	*/
+	const handleTerminalResponse = async (response) => {
+		if (response.flowStatus === EmbeddedSignInFlowStatus.Error) {
+			if (response.redirectUrl && window?.location) {
+				setIsSubmitting(false);
+				await clearFlowState();
+				cleanupOAuthUrlParams(true);
+				onError?.(new Error(extractErrorMessage(response, t)));
+				window.location.href = response.redirectUrl;
+				return true;
+			}
+			if (response.executionId) {
+				setExecutionId(response.executionId);
+				await setChallengeToken(response.challengeToken ?? null);
+				setIsFlowInitialized(true);
+				setFlowError(new Error(extractErrorMessage(response, t)));
+				return true;
+			}
+			await clearFlowState();
+			setError(new Error(extractErrorMessage(response, t)));
+			cleanupFlowUrlParams();
+			return true;
+		}
+		if (response.flowStatus === EmbeddedSignInFlowStatus.Complete) {
+			const finalRedirectUrl = response?.redirectUrl || response?.redirect_uri || afterSignInUrl;
+			setIsSubmitting(false);
+			setExecutionId(null);
+			await setChallengeToken(null);
+			setIsFlowInitialized(false);
+			sessionStorage.removeItem(`${vendor}_execution_id`);
+			try {
+				await (await getStorageManager())?.removeHybridDataParameter?.("authId");
+			} catch {
+				logger.warn("Failed to clear authId from hybrid storage after completion.");
+			}
+			cleanupOAuthUrlParams(true);
+			if (onSuccess) onSuccess({
+				redirectUrl: finalRedirectUrl,
+				...response.data || {}
+			});
+			if (finalRedirectUrl && window?.location) window.location.href = finalRedirectUrl;
+			return true;
+		}
+		return false;
+	};
+	/**
+	* Initialize the authentication flow.
+	* Priority: executionId > applicationId (from context) > applicationId (from URL)
+	*/
+	const initializeFlow = async () => {
+		const urlParams = getUrlParams();
+		oauthCodeProcessedRef.current = false;
+		setServerFieldErrors(null);
+		await handleAuthId(urlParams.authId);
+		const effectiveApplicationId = applicationId || urlParams.applicationId;
+		const storedExecutionId = !urlParams.executionId ? sessionStorage.getItem(`${vendor}_execution_id`) : null;
+		const resumeExecutionId = urlParams.executionId || storedExecutionId;
+		if (!resumeExecutionId && !effectiveApplicationId) {
+			setError(new ThunderIDRuntimeError("Either executionId or applicationId is required for authentication", "SIGN_IN_ERROR", "react"));
+			return;
+		}
+		try {
+			setFlowError(null);
+			let response;
+			if (resumeExecutionId) try {
+				response = await signIn({
+					executionId: resumeExecutionId,
+					...challengeTokenRef.current ? { challengeToken: challengeTokenRef.current } : {}
+				});
+			} catch (resumeError) {
+				if (storedExecutionId && resumeExecutionId === storedExecutionId && resumeError instanceof ThunderIDAPIError && resumeError.statusCode === 400) {
+					setExecutionId(null);
+					try {
+						await (await getStorageManager())?.removeHybridDataParameter?.("authId");
+					} catch {
+						logger.warn("Failed to clear authId from hybrid storage.");
+					}
+					if (!effectiveApplicationId) {
+						setError(new ThunderIDRuntimeError(t("errors.signin.session.expired") || "Your session has expired. Please return to the application and sign in again.", "SIGN_IN_ERROR", "react"));
+						return;
+					}
+					response = await signIn({
+						applicationId: effectiveApplicationId,
+						flowType: EmbeddedFlowType.Authentication,
+						...scopes && { scopes }
+					});
+				} else throw resumeError;
+			}
+			else response = await signIn({
+				applicationId: effectiveApplicationId,
+				flowType: EmbeddedFlowType.Authentication,
+				...scopes && { scopes }
+			});
+			if (await handleRedirection(response)) return;
+			if (await handleTerminalResponse(response)) {
+				if (response.flowStatus === EmbeddedSignInFlowStatus.Error && !response.executionId) initializationAttemptedRef.current = false;
+				return;
+			}
+			const { executionId: normalizedExecutionId, components: normalizedComponents, additionalData: normalizedAdditionalData } = normalizeFlowResponse(response, t, { resolveTranslations: false }, meta);
+			await setChallengeToken(response.challengeToken ?? null);
+			if (normalizedExecutionId && normalizedComponents) {
+				setExecutionId(normalizedExecutionId);
+				setComponents(normalizedComponents);
+				setAdditionalData(normalizedAdditionalData ?? {});
+				setIsFlowInitialized(true);
+				setIsTimeoutDisabled(false);
+				cleanupFlowUrlParams();
+			}
+		} catch (error) {
+			const err = error;
+			await clearFlowState();
+			setError(err instanceof ThunderIDRuntimeError ? err : new Error(extractErrorMessage(err, t)));
+			initializationAttemptedRef.current = false;
+		}
+	};
+	/**
+	* Initialize the flow and handle cleanup of stale flow state.
+	*/
+	useEffect(() => {
+		const urlParams = getUrlParams();
+		if (urlParams.error) {
+			handleOAuthError(urlParams.error, urlParams.errorDescription);
+			return;
+		}
+		handleAuthId(urlParams.authId);
+	}, []);
+	useEffect(() => {
+		const currentUrlParams = getUrlParams();
+		if (isInitialized && isStorageReady && !isLoading && !isFlowInitialized && !initializationAttemptedRef.current && !currentExecutionId && !currentUrlParams.code && !currentUrlParams.state && !isSubmitting && !oauthCodeProcessedRef.current) {
+			initializationAttemptedRef.current = true;
+			initializeFlow();
+		}
+	}, [
+		isInitialized,
+		isStorageReady,
+		isLoading,
+		isFlowInitialized,
+		currentExecutionId
+	]);
+	/**
+	* Handle form submission from BaseSignIn or render props.
+	*/
+	const handleSubmit = async (payload) => {
+		const effectiveExecutionId = payload.executionId || currentExecutionId;
+		if (!effectiveExecutionId) throw new Error("No active flow ID");
+		const processedInputs = { ...payload.inputs };
+		const consentReason = processedInputs[CONSENT_REASON_KEY];
+		delete processedInputs[CONSENT_REASON_KEY];
+		if (additionalData?.["consentPrompt"]) try {
+			const consentPromptRawData = additionalData["consentPrompt"];
+			const purposes = typeof consentPromptRawData === "string" ? JSON.parse(consentPromptRawData) : consentPromptRawData.purposes || consentPromptRawData;
+			let isDeny = false;
+			if (payload.action) {
+				const findAction = (comps) => {
+					if (!comps || comps.length === 0) return null;
+					const found = comps.find((c) => c.id === payload.action);
+					if (found) return found;
+					return comps.reduce((acc, c) => {
+						if (acc) return acc;
+						if (c.components) return findAction(c.components);
+						return null;
+					}, null);
+				};
+				const submitAction = findAction(components);
+				if (submitAction && submitAction.variant?.toLowerCase() !== "primary") isDeny = true;
+			}
+			if (consentReason === ConsentConstants.REASON_TIMEOUT) isDeny = true;
+			const reason = consentReason ?? (isDeny ? ConsentConstants.REASON_USER_DENIED : void 0);
+			const decisions = {
+				approved: !isDeny,
+				...reason ? { reason } : {},
+				purposes: purposes.map((p) => ({
+					approved: !isDeny,
+					elements: [...(p.essential || []).map((e) => ({
+						approved: !isDeny,
+						name: e.name
+					})), ...(p.optional || []).map((e) => {
+						const key = `__consent_opt__${p.purposeId}__${e.name}`;
+						return {
+							approved: !isDeny && processedInputs[key] === "true",
+							name: e.name
+						};
+					})],
+					purposeName: p.purposeName
+				}))
+			};
+			processedInputs["consent_decisions"] = JSON.stringify(decisions);
+			Object.keys(processedInputs).forEach((key) => {
+				if (key.startsWith("__consent_opt__")) delete processedInputs[key];
+			});
+		} catch (e) {}
+		try {
+			setIsSubmitting(true);
+			setFlowError(null);
+			setServerFieldErrors(null);
+			const response = await signIn({
+				executionId: effectiveExecutionId,
+				...payload,
+				inputs: processedInputs,
+				...challengeTokenRef.current ? { challengeToken: challengeTokenRef.current } : {}
+			});
+			if (await handleRedirection(response)) return;
+			if (response.data?.additionalData?.["passkeyChallenge"] || response.data?.additionalData?.["passkeyCreationOptions"]) {
+				const { passkeyChallenge, passkeyCreationOptions } = response.data.additionalData;
+				const effectiveExecutionIdForPasskey = response.executionId || effectiveExecutionId;
+				passkeyProcessedRef.current = false;
+				await setChallengeToken(response.challengeToken ?? null);
+				setPasskeyState({
+					actionId: "submit",
+					challenge: passkeyChallenge,
+					creationOptions: passkeyCreationOptions,
+					error: null,
+					executionId: effectiveExecutionIdForPasskey,
+					isActive: true
+				});
+				setIsSubmitting(false);
+				return;
+			}
+			if (await handleTerminalResponse(response)) return;
+			const { executionId: normalizedExecutionId, components: normalizedComponents, additionalData: normalizedAdditionalData } = normalizeFlowResponse(response, t, { resolveTranslations: false }, meta);
+			await setChallengeToken(response.challengeToken ?? null);
+			if (normalizedExecutionId && normalizedComponents) {
+				setExecutionId(normalizedExecutionId);
+				setComponents(normalizedComponents);
+				setAdditionalData(normalizedAdditionalData ?? {});
+				setIsTimeoutDisabled(false);
+				setIsFlowInitialized(true);
+				cleanupFlowUrlParams();
+				const responseFieldErrors = response.data?.fieldErrors;
+				if (responseFieldErrors && responseFieldErrors.length > 0) setServerFieldErrors(responseFieldErrors);
+				if (response?.error) setFlowError(new Error(extractErrorMessage(response, t)));
+			}
+		} catch (error) {
+			const err = error;
+			await clearFlowState();
+			setError(err instanceof ThunderIDRuntimeError ? err : new Error(extractErrorMessage(err, t)));
+			return;
+		} finally {
+			setIsSubmitting(false);
+		}
+	};
+	/**
+	* Handle step timeout if configured in additionalData.
+	*
+	* An expired consent prompt is auto-submitted as a denial carrying the timeout reason, because its
+	* actions no longer lead anywhere and the user would otherwise be stranded on the prompt. The
+	* server discards those decisions and records nothing. Every other kind of step surfaces the
+	* expiry error instead.
+	*/
+	timeoutContextRef.current = {
+		components,
+		hasConsentPrompt: Boolean(additionalData?.["consentPrompt"]),
+		submit: handleSubmit
+	};
+	useEffect(() => {
+		const timeoutMs = Number(additionalData?.["stepTimeout"]) || 0;
+		if (timeoutMs <= 0 || !isFlowInitialized) {
+			setIsTimeoutDisabled(false);
+			return;
+		}
+		const handleTimeout = () => {
+			setIsTimeoutDisabled(true);
+			const expiredError = () => new Error(t("errors.signin.timeout") || "Time allowed to complete the step has expired.");
+			const context = timeoutContextRef.current;
+			const actionId = context?.hasConsentPrompt ? findConsentSubmitActionId(context.components) : void 0;
+			if (actionId && context && timeoutSubmittedForRef.current !== timeoutMs) {
+				timeoutSubmittedForRef.current = timeoutMs;
+				context.submit({
+					action: actionId,
+					inputs: { [CONSENT_REASON_KEY]: ConsentConstants.REASON_TIMEOUT }
+				}).catch(() => setError(expiredError()));
+				return;
+			}
+			setError(expiredError());
+		};
+		const timerId = setTimeout(handleTimeout, Math.max(0, timeoutMs - Date.now()));
+		return () => clearTimeout(timerId);
+	}, [
+		additionalData?.["stepTimeout"],
+		isFlowInitialized,
+		t
+	]);
+	/**
+	* Handle authentication errors.
+	*/
+	const handleError = (error) => {
+		setError(error);
+	};
+	useOAuthCallback({
+		currentExecutionId,
+		executionIdStorageKey: `${vendor}_execution_id`,
+		isInitialized: isInitialized && !isLoading && isStorageReady,
+		isSubmitting,
+		onError: (err) => {
+			clearFlowState();
+			setError(err instanceof Error ? err : new Error(String(err)));
+		},
+		onSubmit: async (payload) => handleSubmit({
+			executionId: payload.executionId,
+			inputs: payload.inputs
+		}),
+		processedRef: oauthCodeProcessedRef,
+		setExecutionId
+	});
+	/**
+	* Handle passkey authentication/registration when passkey state becomes active.
+	* This effect auto-triggers the browser passkey popup and submits the result.
+	*/
+	useEffect(() => {
+		if (!passkeyState.isActive || !passkeyState.challenge && !passkeyState.creationOptions || !passkeyState.executionId) return;
+		if (passkeyProcessedRef.current) return;
+		passkeyProcessedRef.current = true;
+		const performPasskeyProcess = async () => {
+			let inputs;
+			if (passkeyState.challenge) {
+				const passkeyResponse = await handlePasskeyAuthentication(passkeyState.challenge);
+				const passkeyResponseObj = JSON.parse(passkeyResponse);
+				inputs = {
+					authenticatorData: passkeyResponseObj.response.authenticatorData,
+					clientDataJSON: passkeyResponseObj.response.clientDataJSON,
+					credentialId: passkeyResponseObj.id,
+					signature: passkeyResponseObj.response.signature,
+					userHandle: passkeyResponseObj.response.userHandle
+				};
+			} else if (passkeyState.creationOptions) {
+				const passkeyResponse = await handlePasskeyRegistration(passkeyState.creationOptions);
+				const passkeyResponseObj = JSON.parse(passkeyResponse);
+				inputs = {
+					attestationObject: passkeyResponseObj.response.attestationObject,
+					clientDataJSON: passkeyResponseObj.response.clientDataJSON,
+					credentialId: passkeyResponseObj.id
+				};
+			} else throw new Error("No passkey challenge or creation options available");
+			await handleSubmit({
+				executionId: passkeyState.executionId ?? void 0,
+				inputs
+			});
+		};
+		performPasskeyProcess().then(() => {
+			setPasskeyState({
+				actionId: null,
+				challenge: null,
+				creationOptions: null,
+				error: null,
+				executionId: null,
+				isActive: false
+			});
+		}).catch((error) => {
+			setPasskeyState((prev) => ({
+				...prev,
+				error,
+				isActive: false
+			}));
+			setFlowError(error);
+			onError?.(error);
+		});
+	}, [
+		passkeyState.isActive,
+		passkeyState.challenge,
+		passkeyState.creationOptions,
+		passkeyState.executionId
+	]);
+	if (children) {
+		const renderPropFieldErrors = {};
+		if (serverFieldErrors) {
+			for (const fe of serverFieldErrors) if (!(fe.identifier in renderPropFieldErrors)) renderPropFieldErrors[fe.identifier] = fe.message;
+		}
+		return /* @__PURE__ */ jsx(Fragment$1, { children: children({
+			additionalData,
+			components,
+			error: flowError,
+			fieldErrors: renderPropFieldErrors,
+			initialize: initializeFlow,
+			isInitialized: isFlowInitialized,
+			isLoading: isLoading || isSubmitting || !isInitialized,
+			isTimeoutDisabled,
+			meta,
+			onSubmit: handleSubmit
+		}) });
+	}
+	return /* @__PURE__ */ jsx(BaseSignIn_default, {
+		additionalData,
+		components,
+		isLoading: isLoading || !isInitialized || !isFlowInitialized,
+		isTimeoutDisabled,
+		onSubmit: handleSubmit,
+		onError: handleError,
+		error: flowError,
+		className,
+		size,
+		variant,
+		preferences,
+		revalidateOnChangeAfterBlur,
+		serverFieldErrors
+	});
+};
+var SignIn_default = SignIn;
+
+//#endregion
+export { SignIn_default as default };
+//# sourceMappingURL=SignIn.js.map