@thunderid/react 1.5.0 → 1.6.0

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

@@ -1,662 +0,0 @@
-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/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/presentation/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