@openfort/react 0.3.1 → 1.0.0

package/build/hooks/openfort/auth/useGuestAuth.js

@@ -0,0 +1,142 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { logger } from '../../../utils/logger.js';
+import { onSuccess, onError } from '../hookConsistency.js';
+import { mapStatus } from './status.js';
+import { useConnectToWalletPostAuth } from './useConnectToWalletPostAuth.js';
+
+/**
+ * Hook for guest authentication operations
+ *
+ * This hook manages guest user authentication, allowing users to create temporary
+ * accounts without providing email or other credentials. Guest authentication provides
+ * a quick way for users to get started with the application before committing to
+ * full registration. After authentication, it automatically handles wallet connection.
+ *
+ * @param hookOptions - Optional configuration with callback functions and authentication options
+ * @returns Current guest authentication state and actions
+ *
+ * @example
+ * ```tsx
+ * const guestAuth = useGuestAuth({
+ *   onSignUpGuestSuccess: (result) => console.log('Guest user created:', result.user),
+ *   onSignUpGuestError: (error) => console.error('Guest signup failed:', error),
+ *   recoverWalletAutomatically: true,
+ *   logoutOnError: false,
+ * });
+ *
+ * // Sign up as guest user
+ * const handleGuestSignup = async () => {
+ *   try {
+ *     const result = await guestAuth.signUpGuest();
+ *     if (result.user) {
+ *       console.log('Guest user created:', result.user.id);
+ *       console.log('User wallet:', result.wallet);
+ *     }
+ *   } catch (error) {
+ *     console.error('Guest signup failed:', error);
+ *   }
+ * };
+ *
+ * // Check authentication state
+ * if (guestAuth.isLoading) {
+ *   console.log('Creating guest account...');
+ * } else if (guestAuth.isError) {
+ *   console.error('Guest auth error:', guestAuth.error);
+ * } else if (guestAuth.isSuccess) {
+ *   console.log('Guest authentication successful');
+ * }
+ *
+ * // Example usage in component
+ * return (
+ *   <div>
+ *     <button
+ *       onClick={handleGuestSignup}
+ *       disabled={guestAuth.isLoading}
+ *     >
+ *       {guestAuth.isLoading ? 'Creating Guest Account...' : 'Continue as Guest'}
+ *     </button>
+ *
+ *     {guestAuth.isError && (
+ *       <p>Error: {guestAuth.error?.message}</p>
+ *     )}
+ *   </div>
+ * );
+ * ```
+ */
+const useGuestAuth = (hookOptions = {}) => {
+    const { client, updateUser, updateEmbeddedAccounts } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const { tryUseWallet } = useConnectToWalletPostAuth();
+    const signUpGuest = useCallback(async (options = {}) => {
+        var _a, _b, _c, _d;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            let user;
+            try {
+                logger.log('Guest signup: calling auth.signUpGuest()');
+                const result = await client.auth.signUpGuest();
+                user = result.user;
+                logger.log('Guest signup: auth OK, user id:', user === null || user === void 0 ? void 0 : user.id);
+            }
+            catch (authError) {
+                const isAlreadyLoggedIn = ((_a = authError === null || authError === void 0 ? void 0 : authError.message) === null || _a === void 0 ? void 0 : _a.includes('Already logged in')) ||
+                    (authError === null || authError === void 0 ? void 0 : authError.name) === 'SessionError';
+                if (isAlreadyLoggedIn) {
+                    logger.log('Guest signup: already logged in, using existing session');
+                    user = (_b = (await client.user.get())) !== null && _b !== void 0 ? _b : undefined;
+                    if (!user)
+                        throw authError;
+                }
+                else {
+                    throw authError;
+                }
+            }
+            await updateUser(user);
+            logger.log('Guest signup: calling tryUseWallet()');
+            const { wallet } = await tryUseWallet({
+                logoutOnError: (_c = options.logoutOnError) !== null && _c !== void 0 ? _c : hookOptions.logoutOnError,
+                recoverWalletAutomatically: (_d = options.recoverWalletAutomatically) !== null && _d !== void 0 ? _d : hookOptions.recoverWalletAutomatically,
+            });
+            if (wallet && typeof updateEmbeddedAccounts === 'function') {
+                await updateEmbeddedAccounts();
+            }
+            setStatus({
+                status: 'success',
+            });
+            logger.log('Guest signup: success', wallet ? '(wallet created)' : '(no wallet)');
+            return onSuccess({
+                hookOptions,
+                options,
+                data: { user, wallet },
+            });
+        }
+        catch (error) {
+            logger.error('Guest signup failed:', error);
+            const openfortError = new OpenfortError('Failed to signup guest', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error,
+            });
+            setStatus({
+                status: 'error',
+                error: openfortError,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: openfortError,
+            });
+        }
+    }, [client, setStatus, updateUser, updateEmbeddedAccounts, tryUseWallet, hookOptions]);
+    return {
+        signUpGuest,
+        ...mapStatus(status),
+    };
+};
+
+export { useGuestAuth };
+//# sourceMappingURL=useGuestAuth.js.map

package/build/hooks/openfort/auth/useGuestAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGuestAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/auth/useOAuth.d.ts

@@ -1,6 +1,7 @@
 import type { OAuthProvider, User } from '@openfort/openfort-js';
-import { OpenfortError, type OpenfortHookOptions } from '../../../types';
-import type { UserWallet } from '../useWallets';
+import { OpenfortError } from '../../../core/errors';
+import type { OpenfortHookOptions } from '../../../types';
+import type { EthereumUserWallet, SolanaUserWallet } from '../walletTypes';
 import { type CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 type InitializeOAuthOptions = {
     provider: OAuthProvider;
@@ -11,7 +12,7 @@ type InitOAuthReturnType = {
 };
 export type StoreCredentialsResult = {
     user?: User;
-    wallet?: UserWallet;
+    wallet?: EthereumUserWallet | SolanaUserWallet;
     error?: OpenfortError;
 };
 type StoreCredentialsOptions = {

package/build/hooks/openfort/auth/useOAuth.js

@@ -0,0 +1,217 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { onSuccess, onError } from '../hookConsistency.js';
+import { useUI } from '../useUI.js';
+import { buildCallbackUrl } from './requestEmailVerification.js';
+import { mapStatus } from './status.js';
+import { useConnectToWalletPostAuth } from './useConnectToWalletPostAuth.js';
+
+/**
+ * Hook for OAuth-based authentication operations
+ *
+ * This hook manages OAuth authentication flows including provider initialization,
+ * credential storage, and wallet connection after successful OAuth authentication.
+ * It supports multiple OAuth providers and handles the complete authentication lifecycle
+ * from provider selection to wallet setup.
+ *
+ * @param hookOptions - Optional configuration with callback functions and authentication options
+ * @returns Current OAuth authentication state and actions
+ *
+ * @example
+ * ```tsx
+ * const oauth = useOAuth({
+ *   onInitializeOAuthSuccess: (result) => console.log('OAuth initialized'),
+ *   onInitializeOAuthError: (error) => console.error('OAuth init failed:', error),
+ *   onStoreCredentialsSuccess: (result) => console.log('Authenticated:', result.user),
+ *   redirectTo: 'https://yourapp.com/auth/callback',
+ *   recoverWalletAutomatically: true,
+ * });
+ *
+ * // Initialize OAuth with a provider
+ * const handleGoogleAuth = async () => {
+ *   await oauth.initOAuth({
+ *     provider: OAuthProvider.GOOGLE,
+ *     redirectTo: 'https://yourapp.com/auth/callback',
+ *   });
+ * };
+ *
+ * const handleDiscordAuth = async () => {
+ *   await oauth.initOAuth({
+ *     provider: OAuthProvider.DISCORD,
+ *   });
+ * };
+ *
+ * // Store OAuth credentials (typically called from callback handler)
+ * const handleStoreCredentials = async () => {
+ *   await oauth.storeCredentials({
+ *     player: 'player-id-from-callback',
+ *     accessToken: 'access-token-from-callback',
+ *     refreshToken: 'refresh-token-from-callback',
+ *   });
+ * };
+ *
+ * // Link OAuth provider to existing authenticated account
+ * const handleLinkOAuth = async () => {
+ *   await oauth.linkOauth({
+ *     provider: OAuthProvider.GOOGLE,
+ *     redirectTo: 'https://yourapp.com/auth/callback',
+ *   });
+ * };
+ *
+ * // Check authentication state
+ * if (oauth.isLoading) {
+ *   console.log('Processing OAuth authentication...');
+ * } else if (oauth.isError) {
+ *   console.error('OAuth error:', oauth.error);
+ * } else if (oauth.isSuccess) {
+ *   console.log('OAuth authentication successful');
+ * }
+ *
+ * // Example usage in component with multiple providers
+ * return (
+ *   <div>
+ *     <button onClick={handleGoogleAuth} disabled={oauth.isLoading}>
+ *       Sign in with Google
+ *     </button>
+ *     <button onClick={handleDiscordAuth} disabled={oauth.isLoading}>
+ *       Sign in with Discord
+ *     </button>
+ *   </div>
+ * );
+ * ```
+ */
+const useOAuth = (hookOptions = {}) => {
+    const { client, updateUser } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const { isOpen } = useUI();
+    const { tryUseWallet } = useConnectToWalletPostAuth();
+    const storeCredentials = useCallback(async ({ userId, token, ...options }) => {
+        var _a, _b;
+        setStatus({
+            status: 'loading',
+        });
+        try {
+            await client.auth.storeCredentials({
+                userId,
+                token,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = (await updateUser()) || undefined;
+            const { wallet } = await tryUseWallet({
+                logoutOnError: (_a = options.logoutOnError) !== null && _a !== void 0 ? _a : hookOptions.logoutOnError,
+                recoverWalletAutomatically: (_b = options.recoverWalletAutomatically) !== null && _b !== void 0 ? _b : hookOptions.recoverWalletAutomatically,
+            });
+            return onSuccess({
+                data: { user, wallet, type: 'storeCredentials' },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to store credentials', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, hookOptions]);
+    const initOAuth = useCallback(async (options) => {
+        var _a;
+        const authProvider = options.provider;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            const redirectUrl = await client.auth.initOAuth({
+                provider: authProvider,
+                redirectTo: buildCallbackUrl({
+                    provider: authProvider,
+                    callbackUrl: (_a = hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.redirectTo,
+                    isOpen,
+                }),
+            });
+            window.location.href = redirectUrl;
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with OAuth', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions, isOpen]);
+    const linkOauth = useCallback(async (options) => {
+        var _a;
+        const authProvider = options.provider;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            const authToken = await client.getAccessToken();
+            if (!authToken) {
+                throw new OpenfortError('No auth token found', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            }
+            const redirectUrl = await client.auth.initLinkOAuth({
+                provider: authProvider,
+                redirectTo: buildCallbackUrl({
+                    provider: authProvider,
+                    callbackUrl: (_a = options === null || options === void 0 ? void 0 : options.redirectTo) !== null && _a !== void 0 ? _a : hookOptions === null || hookOptions === void 0 ? void 0 : hookOptions.redirectTo,
+                    isOpen,
+                }),
+            });
+            window.location.href = redirectUrl;
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to link OAuth', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions, isOpen]);
+    return {
+        initOAuth,
+        linkOauth,
+        storeCredentials,
+        ...mapStatus(status),
+    };
+};
+
+export { useOAuth };
+//# sourceMappingURL=useOAuth.js.map

package/build/hooks/openfort/auth/useOAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/auth/usePhoneOtpAuth.d.ts

@@ -1,11 +1,12 @@
 import type { User } from '@openfort/openfort-js';
-import { OpenfortError, type OpenfortHookOptions } from '../../../types';
-import type { UserWallet } from '../useWallets';
+import { OpenfortError } from '../../../core/errors';
+import type { OpenfortHookOptions } from '../../../types';
+import type { EthereumUserWallet, SolanaUserWallet } from '../walletTypes';
 import { type CreateWalletPostAuthOptions } from './useConnectToWalletPostAuth';
 type PhoneAuthResult = {
     error?: OpenfortError;
     user?: User;
-    wallet?: UserWallet;
+    wallet?: EthereumUserWallet | SolanaUserWallet;
 };
 type LoginWithPhoneOtpOptions = {
     phoneNumber: string;

package/build/hooks/openfort/auth/usePhoneOtpAuth.js

@@ -0,0 +1,174 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { onError, onSuccess } from '../hookConsistency.js';
+import { mapStatus } from './status.js';
+import { useConnectToWalletPostAuth } from './useConnectToWalletPostAuth.js';
+
+const usePhoneOtpAuth = (hookOptions = {}) => {
+    const { client, updateUser } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const reset = useCallback(() => {
+        setStatus({
+            status: 'idle',
+        });
+    }, []);
+    const { tryUseWallet } = useConnectToWalletPostAuth();
+    const logInWithPhoneOtp = useCallback(async (options) => {
+        var _a, _b;
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.phoneNumber || !options.otp) {
+                const error = new OpenfortError('Phone and OTP are required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.logInWithPhoneOtp({
+                phoneNumber: options.phoneNumber,
+                otp: options.otp,
+            });
+            const { wallet } = await tryUseWallet({
+                logoutOnError: (_a = options.logoutOnError) !== null && _a !== void 0 ? _a : hookOptions.logoutOnError,
+                recoverWalletAutomatically: (_b = options.recoverWalletAutomatically) !== null && _b !== void 0 ? _b : hookOptions.recoverWalletAutomatically,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = result.user;
+            await updateUser();
+            return onSuccess({
+                data: { user, wallet },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with phone OTP', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const requestPhoneOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'requesting',
+            });
+            if (!options.phoneNumber) {
+                const error = new OpenfortError('Phone number is required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            await client.auth.requestPhoneOtp({
+                phoneNumber: options.phoneNumber,
+            });
+            setStatus({
+                status: 'idle',
+            });
+            return onSuccess({
+                data: {},
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to request phone OTP', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    const linkPhoneOtp = useCallback(async (options) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            if (!options.phoneNumber || !options.otp) {
+                const error = new OpenfortError('Phone and OTP are required', OpenfortReactErrorType.VALIDATION_ERROR);
+                setStatus({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    hookOptions,
+                    options,
+                    error,
+                });
+            }
+            const result = await client.auth.linkPhoneOtp({
+                phoneNumber: options.phoneNumber,
+                otp: options.otp,
+            });
+            setStatus({
+                status: 'success',
+            });
+            const user = result.user;
+            await updateUser();
+            return onSuccess({
+                data: { user },
+                hookOptions,
+                options,
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to link phone OTP', OpenfortReactErrorType.AUTHENTICATION_ERROR, {
+                error: e,
+            });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    return {
+        logInWithPhoneOtp,
+        requestPhoneOtp,
+        linkPhoneOtp,
+        reset,
+        isRequesting: status.status === 'requesting',
+        ...mapStatus(status),
+        isAwaitingInput: status.status === 'awaiting-input',
+    };
+};
+
+export { usePhoneOtpAuth };
+//# sourceMappingURL=usePhoneOtpAuth.js.map

package/build/hooks/openfort/auth/usePhoneOtpAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePhoneOtpAuth.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/hooks/openfort/auth/useSignOut.d.ts

@@ -1,4 +1,5 @@
-import { OpenfortError, type OpenfortHookOptions } from '../../../types';
+import { OpenfortError } from '../../../core/errors';
+import type { OpenfortHookOptions } from '../../../types';
 /**
  * Hook for user sign out operations
  *

package/build/hooks/openfort/auth/useSignOut.js

@@ -0,0 +1,104 @@
+import { useState, useCallback } from 'react';
+import { OpenfortError, OpenfortReactErrorType } from '../../../types.js';
+import { useOpenfortCore } from '../../../openfort/useOpenfort.js';
+import { onSuccess, onError } from '../hookConsistency.js';
+import { mapStatus } from './status.js';
+
+/**
+ * Hook for user sign out operations
+ *
+ * This hook manages user logout functionality, clearing authentication state
+ * and disconnecting from all services. It provides a clean way to sign out users
+ * while handling any cleanup operations and providing loading/error states.
+ * The hook ensures complete logout by clearing all stored credentials and state.
+ *
+ * @param hookOptions - Optional configuration with callback functions
+ * @returns Current sign out state and actions
+ *
+ * @example
+ * ```tsx
+ * const signOutHook = useSignOut({
+ *   onSignOutSuccess: () => console.log('User signed out successfully'),
+ *   onSignOutError: (error) => console.error('Sign out failed:', error),
+ * });
+ *
+ * // Sign out user
+ * const handleSignOut = async () => {
+ *   try {
+ *     await signOutHook.signOut();
+ *     console.log('User has been signed out');
+ *     // Redirect to login page or update UI
+ *   } catch (error) {
+ *     console.error('Sign out failed:', error);
+ *   }
+ * };
+ *
+ * // Sign out with custom options
+ * const handleCustomSignOut = async () => {
+ *   await signOutHook.signOut({
+ *     onSuccess: () => console.log('Custom success handler'),
+ *     onError: (error) => console.error('Custom error handler:', error),
+ *   });
+ * };
+ *
+ * // Check sign out state
+ * if (signOutHook.isLoading) {
+ *   console.log('Signing out...');
+ * } else if (signOutHook.isError) {
+ *   console.error('Sign out error:', signOutHook.error);
+ * } else if (signOutHook.isSuccess) {
+ *   console.log('Sign out successful');
+ * }
+ *
+ * // Example usage in component
+ * return (
+ *   <button
+ *     onClick={handleSignOut}
+ *     disabled={signOutHook.isLoading}
+ *   >
+ *     {signOutHook.isLoading ? 'Signing out...' : 'Sign Out'}
+ *   </button>
+ * );
+ * ```
+ */
+function useSignOut(hookOptions = {}) {
+    const { logout } = useOpenfortCore();
+    const [status, setStatus] = useState({
+        status: 'idle',
+    });
+    const signOut = useCallback(async (options = {}) => {
+        setStatus({
+            status: 'loading',
+        });
+        try {
+            logout();
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {},
+            });
+        }
+        catch {
+            const error = new OpenfortError('Failed to sign out', OpenfortReactErrorType.AUTHENTICATION_ERROR);
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [logout, setStatus, hookOptions]);
+    return {
+        ...mapStatus(status),
+        signOut,
+    };
+}
+
+export { useSignOut };
+//# sourceMappingURL=useSignOut.js.map