@insforge/react 0.5.11 → 0.6.1

package/dist/index.js

@@ -12,9 +12,10 @@ if (typeof document !== 'undefined' && typeof window !== 'undefined') {
   }
 }
 
-import { createContext, useContext, useState, useRef, useCallback, useEffect, useMemo, isValidElement, cloneElement } from 'react';
+import { createContext, useContext, useState, useMemo, useEffect, useRef, useCallback, isValidElement, cloneElement } from 'react';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { createClient } from '@insforge/sdk';
+import { InsforgeContext } from '@insforge/shared/react';
 import { AlertTriangle, Check, EyeOff, Eye, Loader2, CircleCheck, LogOut } from 'lucide-react';
 import { z } from 'zod';
 
@@ -62,34 +63,82 @@ function useSearchParams() {
   const adapter = useNavigationAdapter();
   return adapter.useSearchParams();
 }
-var InsforgeContext = createContext(void 0);
-function InsforgeProviderCore({
-  children,
-  baseUrl,
-  afterSignInUrl = "/",
-  onAuthChange,
-  onSignIn,
-  onSignOut
-}) {
-  const [user, setUser] = useState(null);
-  const [isLoaded, setIsLoaded] = useState(false);
-  const refreshIntervalRef = useRef(null);
-  const hasProcessedCallbackRef = useRef(false);
-  const [insforge] = useState(() => createClient({ baseUrl }));
-  const loadAuthState = useCallback(async () => {
+var InsforgeManager = class _InsforgeManager {
+  // Static private instance
+  static instance = null;
+  // State storage
+  user = null;
+  isLoaded = false;
+  sdk;
+  listeners = /* @__PURE__ */ new Set();
+  // Config
+  config;
+  refreshIntervalRef = null;
+  hasProcessedCallbackRef = false;
+  // Private constructor (prevents external instantiation)
+  constructor(config) {
+    this.config = config;
+    this.sdk = createClient({ baseUrl: config.baseUrl });
+  }
+  // Public access method (Singleton core)
+  static getInstance(config) {
+    if (typeof window !== "undefined" && _InsforgeManager.instance) {
+      _InsforgeManager.instance.updateConfig(config);
+      return _InsforgeManager.instance;
+    }
+    _InsforgeManager.instance = new _InsforgeManager(config);
+    return _InsforgeManager.instance;
+  }
+  // Clear instance (used for testing or cleanup)
+  static clearInstance() {
+    if (_InsforgeManager.instance) {
+      _InsforgeManager.instance.cleanup();
+    }
+    _InsforgeManager.instance = null;
+  }
+  // Update config (for hot reloads)
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  // Public initialization method
+  async initialize() {
+    if (!this.isLoaded) {
+      await this.loadAuthState();
+    }
+  }
+  // Get current state
+  getState() {
+    return {
+      user: this.user,
+      isLoaded: this.isLoaded,
+      isSignedIn: !!this.user
+    };
+  }
+  // Subscription mechanism
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners() {
+    const state = this.getState();
+    this.listeners.forEach((listener) => listener(state));
+  }
+  // Load auth state
+  async loadAuthState() {
     try {
-      const sessionResult = insforge.auth.getCurrentSession();
+      const sessionResult = this.sdk.auth.getCurrentSession();
       const session = sessionResult.data?.session;
       const token = session?.accessToken || null;
       if (!token) {
-        setUser(null);
-        if (onAuthChange) {
-          onAuthChange(null);
+        this.user = null;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(null);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: false, error: "no_session" };
       }
-      const userResult = await insforge.auth.getCurrentUser();
+      const userResult = await this.sdk.auth.getCurrentUser();
       if (userResult.data) {
         const profile = userResult.data.profile;
         const userData = {
@@ -98,326 +147,357 @@ function InsforgeProviderCore({
           name: profile?.nickname || "",
           avatarUrl: profile?.avatarUrl || ""
         };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
+        this.user = userData;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(userData);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: true };
       } else {
-        await insforge.auth.signOut();
-        if (onSignOut) {
+        await this.sdk.auth.signOut();
+        if (this.config.onSignOut) {
           try {
-            await onSignOut();
+            await this.config.onSignOut();
           } catch (error) {
             if (error instanceof Error) {
-              console.error("[InsforgeProvider] Error clearing cookie:", error.message);
+              console.error("[InsforgeManager] Error clearing cookie:", error.message);
             }
           }
         }
-        setUser(null);
-        if (onAuthChange) {
-          onAuthChange(null);
+        this.user = null;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(null);
         }
-        setIsLoaded(true);
+        this.isLoaded = true;
+        this.notifyListeners();
         return { success: false, error: "invalid_token" };
       }
     } catch (error) {
-      console.error("[InsforgeProvider] Token validation failed:", error);
-      await insforge.auth.signOut();
-      if (onSignOut) {
+      console.error("[InsforgeManager] Token validation failed:", error);
+      await this.sdk.auth.signOut();
+      if (this.config.onSignOut) {
         try {
-          await onSignOut();
+          await this.config.onSignOut();
         } catch (error2) {
           if (error2 instanceof Error) {
-            console.error("[InsforgeProvider] Error clearing cookie:", error2.message);
+            console.error("[InsforgeManager] Error clearing cookie:", error2.message);
           }
         }
       }
-      setUser(null);
-      if (onAuthChange) {
-        onAuthChange(null);
+      this.user = null;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(null);
       }
-      setIsLoaded(true);
+      this.isLoaded = true;
+      this.notifyListeners();
       return {
         success: false,
         error: error instanceof Error ? error.message : "Authentication failed"
       };
     }
-  }, [insforge, onAuthChange, onSignOut]);
-  useEffect(() => {
-    loadAuthState();
-    const intervalId = refreshIntervalRef.current;
-    return () => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-    };
-  }, [loadAuthState]);
-  useEffect(() => {
-    if (!isLoaded || hasProcessedCallbackRef.current) {
-      return;
-    }
-    const searchParams = new URLSearchParams(window.location.search);
-    const accessToken = searchParams.get("access_token");
-    if (accessToken && !!user) {
-      hasProcessedCallbackRef.current = true;
-      const url = new URL(window.location.href);
-      url.search = "";
-      window.history.replaceState({}, "", url.toString());
-      setTimeout(() => {
-        window.location.href = afterSignInUrl;
-      }, 100);
-    }
-  }, [isLoaded, user, afterSignInUrl]);
-  const getPublicAuthConfig = useCallback(async () => {
-    try {
-      const result = await insforge.auth.getPublicAuthConfig();
-      if (result.data) {
-        return result.data;
-      } else {
-        console.error("[InsforgeProvider] Failed to get public auth config:", result.error);
-        return null;
+  }
+  // Helper to handle auth success
+  async handleAuthSuccess(authToken, fallbackUser) {
+    const userResult = await this.sdk.auth.getCurrentUser();
+    if (userResult.data) {
+      const profile = userResult.data.profile;
+      const userData = {
+        id: userResult.data.user.id,
+        email: userResult.data.user.email,
+        name: profile?.nickname || "",
+        avatarUrl: profile?.avatarUrl || ""
+      };
+      this.user = userData;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(userData);
       }
-    } catch (error) {
-      console.error("[InsforgeProvider] Failed to get public auth config:", error);
-      return null;
-    }
-  }, [insforge]);
-  const handleAuthSuccess = useCallback(
-    async (authToken, fallbackUser) => {
-      const userResult = await insforge.auth.getCurrentUser();
-      if (userResult.data) {
-        const profile = userResult.data.profile;
-        const userData = {
-          id: userResult.data.user.id,
-          email: userResult.data.user.email,
-          name: profile?.nickname || "",
-          avatarUrl: profile?.avatarUrl || ""
-        };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
-        }
-        if (onSignIn) {
-          try {
-            await onSignIn(authToken);
-          } catch (error) {
-            if (error instanceof Error) {
-              console.error("[InsforgeProvider] Error syncing token to cookie:", error.message);
-            }
+      if (this.config.onSignIn) {
+        try {
+          await this.config.onSignIn(authToken);
+        } catch (error) {
+          if (error instanceof Error) {
+            console.error("[InsforgeManager] Error syncing token to cookie:", error.message);
           }
         }
-      } else if (fallbackUser) {
-        const userData = {
-          id: fallbackUser.id || "",
-          email: fallbackUser.email || "",
-          name: fallbackUser.name || "",
-          avatarUrl: ""
-        };
-        setUser(userData);
-        if (onAuthChange) {
-          onAuthChange(userData);
-        }
       }
-    },
-    [insforge, onAuthChange, onSignIn]
-  );
-  const signIn = useCallback(
-    async (email, password) => {
-      const sdkResult = await insforge.auth.signInWithPassword({
-        email,
-        password
-      });
-      if (sdkResult.data) {
-        await handleAuthSuccess(
-          sdkResult.data.accessToken || "",
+      this.notifyListeners();
+    } else if (fallbackUser) {
+      const userData = {
+        id: fallbackUser.id || "",
+        email: fallbackUser.email || "",
+        name: fallbackUser.name || "",
+        avatarUrl: ""
+      };
+      this.user = userData;
+      if (this.config.onAuthChange) {
+        this.config.onAuthChange(userData);
+      }
+      this.notifyListeners();
+    }
+  }
+  // Business methods
+  async signIn(email, password) {
+    const sdkResult = await this.sdk.auth.signInWithPassword({
+      email,
+      password
+    });
+    if (sdkResult.data) {
+      await this.handleAuthSuccess(
+        sdkResult.data.accessToken || "",
+        sdkResult.data.user ? {
+          id: sdkResult.data.user.id,
+          email: sdkResult.data.user.email,
+          name: sdkResult.data.user.name
+        } : void 0
+      );
+      return sdkResult.data;
+    } else {
+      return {
+        error: sdkResult.error?.message || "Invalid email or password",
+        statusCode: sdkResult.error?.statusCode,
+        errorCode: sdkResult.error?.error
+      };
+    }
+  }
+  async signUp(email, password) {
+    const sdkResult = await this.sdk.auth.signUp({ email, password });
+    if (sdkResult.data) {
+      if (sdkResult.data.accessToken) {
+        await this.handleAuthSuccess(
+          sdkResult.data.accessToken,
           sdkResult.data.user ? {
             id: sdkResult.data.user.id,
             email: sdkResult.data.user.email,
             name: sdkResult.data.user.name
           } : void 0
         );
-        return sdkResult.data;
-      } else {
-        return {
-          error: sdkResult.error?.message || "Invalid email or password",
-          statusCode: sdkResult.error?.statusCode,
-          errorCode: sdkResult.error?.error
-        };
-      }
-    },
-    [insforge, handleAuthSuccess]
-  );
-  const signUp = useCallback(
-    async (email, password) => {
-      const sdkResult = await insforge.auth.signUp({ email, password });
-      if (sdkResult.data) {
-        if (sdkResult.data.accessToken) {
-          await handleAuthSuccess(
-            sdkResult.data.accessToken,
-            sdkResult.data.user ? {
-              id: sdkResult.data.user.id,
-              email: sdkResult.data.user.email,
-              name: sdkResult.data.user.name
-            } : void 0
-          );
-        }
-        return sdkResult.data;
-      } else {
-        return {
-          error: sdkResult.error?.message || "Sign up failed",
-          statusCode: sdkResult.error?.statusCode,
-          errorCode: sdkResult.error?.error
-        };
       }
-    },
-    [insforge, handleAuthSuccess]
-  );
-  const signOut = useCallback(async () => {
-    await insforge.auth.signOut();
-    if (onSignOut) {
+      return sdkResult.data;
+    } else {
+      return {
+        error: sdkResult.error?.message || "Sign up failed",
+        statusCode: sdkResult.error?.statusCode,
+        errorCode: sdkResult.error?.error
+      };
+    }
+  }
+  async signOut() {
+    await this.sdk.auth.signOut();
+    if (this.config.onSignOut) {
       try {
-        await onSignOut();
+        await this.config.onSignOut();
       } catch (error) {
         if (error instanceof Error) {
-          console.error("[InsforgeProvider] Error clearing cookie:", error.message);
+          console.error("[InsforgeManager] Error clearing cookie:", error.message);
         }
       }
     }
-    if (refreshIntervalRef.current) {
-      clearInterval(refreshIntervalRef.current);
+    if (this.refreshIntervalRef) {
+      clearInterval(this.refreshIntervalRef);
+      this.refreshIntervalRef = null;
     }
-    setUser(null);
-    if (onAuthChange) {
-      onAuthChange(null);
+    this.user = null;
+    if (this.config.onAuthChange) {
+      this.config.onAuthChange(null);
     }
-  }, [insforge, onAuthChange, onSignOut]);
-  const updateUser = useCallback(
-    async (data) => {
-      if (!user) {
-        return { error: "No user signed in" };
-      }
-      const profileUpdate = {
-        nickname: data.name,
-        avatarUrl: data.avatarUrl
-      };
-      const result = await insforge.auth.setProfile(profileUpdate);
-      if (result.data) {
-        const userResult = await insforge.auth.getCurrentUser();
-        if (userResult.data) {
-          const profile = userResult.data.profile;
-          const updatedUser = {
-            id: userResult.data.user.id,
-            email: userResult.data.user.email,
-            name: profile?.nickname || "",
-            avatarUrl: profile?.avatarUrl || ""
-          };
-          setUser(updatedUser);
-          if (onAuthChange) {
-            onAuthChange(updatedUser);
-          }
+    this.notifyListeners();
+  }
+  async updateUser(data) {
+    if (!this.user) {
+      return { error: "No user signed in" };
+    }
+    const profileUpdate = {
+      nickname: data.name,
+      avatarUrl: data.avatarUrl
+    };
+    const result = await this.sdk.auth.setProfile(profileUpdate);
+    if (result.data) {
+      const userResult = await this.sdk.auth.getCurrentUser();
+      if (userResult.data) {
+        const profile = userResult.data.profile;
+        const updatedUser = {
+          id: userResult.data.user.id,
+          email: userResult.data.user.email,
+          name: profile?.nickname || "",
+          avatarUrl: profile?.avatarUrl || ""
+        };
+        this.user = updatedUser;
+        if (this.config.onAuthChange) {
+          this.config.onAuthChange(updatedUser);
         }
-        return null;
-      } else {
-        return { error: result.error?.message || "Failed to update user" };
+        this.notifyListeners();
       }
-    },
-    [user, onAuthChange, insforge]
-  );
-  const sendVerificationEmail = useCallback(
-    async (email) => {
-      const sdkResult = await insforge.auth.sendVerificationEmail({ email });
-      return sdkResult.data;
-    },
-    [insforge]
-  );
-  const sendResetPasswordEmail = useCallback(
-    async (email) => {
-      const sdkResult = await insforge.auth.sendResetPasswordEmail({ email });
+      return null;
+    }
+    const error = result.error;
+    return { error: error?.message || "Failed to update user" };
+  }
+  async reloadAuth() {
+    return await this.loadAuthState();
+  }
+  async sendVerificationEmail(email) {
+    const sdkResult = await this.sdk.auth.sendVerificationEmail({ email });
+    return sdkResult.data;
+  }
+  async sendResetPasswordEmail(email) {
+    const sdkResult = await this.sdk.auth.sendResetPasswordEmail({ email });
+    return sdkResult.data;
+  }
+  async resetPassword(token, newPassword) {
+    const sdkResult = await this.sdk.auth.resetPassword({
+      newPassword,
+      otp: token
+    });
+    return sdkResult.data;
+  }
+  async verifyEmail(otp, email) {
+    const sdkResult = await this.sdk.auth.verifyEmail({ otp, email: email || void 0 });
+    if (sdkResult.data) {
       return sdkResult.data;
-    },
-    [insforge]
-  );
-  const resetPassword = useCallback(
-    async (token, newPassword) => {
-      const sdkResult = await insforge.auth.resetPassword({
-        newPassword,
-        otp: token
-      });
+    } else {
+      return {
+        accessToken: "",
+        error: {
+          message: sdkResult.error?.message || "Email verification failed"
+        }
+      };
+    }
+  }
+  async exchangeResetPasswordToken(email, code) {
+    const sdkResult = await this.sdk.auth.exchangeResetPasswordToken({ email, code });
+    if (sdkResult.data) {
       return sdkResult.data;
-    },
-    [insforge]
-  );
-  const verifyEmail = useCallback(
-    async (otp, email) => {
-      const sdkResult = await insforge.auth.verifyEmail({ otp, email: email || void 0 });
-      if (sdkResult.data) {
-        return sdkResult.data;
-      } else {
-        return {
-          accessToken: "",
-          error: {
-            message: sdkResult.error?.message || "Email verification failed"
-          }
-        };
-      }
-    },
-    [insforge]
-  );
-  const exchangeResetPasswordToken = useCallback(
-    async (email, code) => {
-      const sdkResult = await insforge.auth.exchangeResetPasswordToken({ email, code });
-      if (sdkResult.data) {
-        return sdkResult.data;
+    } else {
+      return {
+        error: {
+          message: sdkResult.error?.message || "Failed to exchange reset password token"
+        }
+      };
+    }
+  }
+  async loginWithOAuth(provider, redirectTo) {
+    const sdkResult = await this.sdk.auth.signInWithOAuth({
+      provider,
+      redirectTo: redirectTo || window.location.origin + (this.config.afterSignInUrl || "/")
+    });
+    if (sdkResult.error) {
+      throw new Error(sdkResult.error.message);
+    }
+  }
+  async getPublicAuthConfig() {
+    try {
+      const result = await this.sdk.auth.getPublicAuthConfig();
+      if (result.data) {
+        return result.data;
       } else {
-        return {
-          error: {
-            message: sdkResult.error?.message || "Failed to exchange reset password token"
-          }
-        };
-      }
-    },
-    [insforge]
-  );
-  const loginWithOAuth = useCallback(
-    async (provider, redirectTo) => {
-      const sdkResult = await insforge.auth.signInWithOAuth({
-        provider,
-        redirectTo: redirectTo || window.location.origin + afterSignInUrl
-      });
-      if (sdkResult.error) {
-        throw new Error(sdkResult.error.message);
+        console.error("[InsforgeManager] Failed to get public auth config:", result.error);
+        return null;
       }
-    },
-    [insforge, afterSignInUrl]
-  );
-  return /* @__PURE__ */ jsx(
-    InsforgeContext.Provider,
-    {
-      value: {
-        user,
-        isLoaded,
-        isSignedIn: !!user,
-        setUser,
-        signIn,
-        signUp,
-        signOut,
-        updateUser,
-        reloadAuth: loadAuthState,
-        sendVerificationEmail,
-        sendResetPasswordEmail,
-        resetPassword,
-        verifyEmail,
-        exchangeResetPasswordToken,
-        getPublicAuthConfig,
-        loginWithOAuth,
-        baseUrl,
-        afterSignInUrl
-      },
-      children
+    } catch (error) {
+      console.error("[InsforgeManager] Failed to get public auth config:", error);
+      return null;
+    }
+  }
+  setUser(user) {
+    this.user = user;
+    if (this.config.onAuthChange) {
+      this.config.onAuthChange(user);
+    }
+    this.notifyListeners();
+  }
+  getConfig() {
+    return this.config;
+  }
+  getSDK() {
+    return this.sdk;
+  }
+  // Handle OAuth callback
+  handleOAuthCallback(isLoaded, user) {
+    if (!isLoaded || this.hasProcessedCallbackRef) {
+      return false;
+    }
+    const searchParams = new URLSearchParams(window.location.search);
+    const accessToken = searchParams.get("access_token");
+    if (accessToken && !!user) {
+      this.hasProcessedCallbackRef = true;
+      const url = new URL(window.location.href);
+      url.search = "";
+      window.history.replaceState({}, "", url.toString());
+      setTimeout(() => {
+        window.location.href = this.config.afterSignInUrl || "/";
+      }, 100);
+      return true;
     }
+    return false;
+  }
+  // Cleanup
+  cleanup() {
+    if (this.refreshIntervalRef) {
+      clearInterval(this.refreshIntervalRef);
+      this.refreshIntervalRef = null;
+    }
+    this.listeners.clear();
+  }
+};
+function InsforgeProviderCore({
+  children,
+  baseUrl,
+  afterSignInUrl = "/",
+  onAuthChange,
+  onSignIn,
+  onSignOut
+}) {
+  const manager = useMemo(
+    () => InsforgeManager.getInstance({
+      baseUrl,
+      afterSignInUrl,
+      onAuthChange,
+      onSignIn,
+      onSignOut
+    }),
+    [baseUrl, afterSignInUrl, onAuthChange, onSignIn, onSignOut]
   );
+  const [state, setState] = useState(() => manager.getState());
+  useEffect(() => {
+    const unsubscribe = manager.subscribe((newState) => {
+      setState(newState);
+    });
+    void manager.initialize();
+    return unsubscribe;
+  }, [manager]);
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      manager.handleOAuthCallback(state.isLoaded, state.user);
+    }
+  }, [manager, state.isLoaded, state.user]);
+  const contextValue = useMemo(
+    () => ({
+      // State from Manager
+      user: state.user,
+      isLoaded: state.isLoaded,
+      isSignedIn: state.isSignedIn,
+      // Methods delegated to Manager
+      setUser: (user) => manager.setUser(user),
+      signIn: (email, password) => manager.signIn(email, password),
+      signUp: (email, password) => manager.signUp(email, password),
+      signOut: () => manager.signOut(),
+      updateUser: (data) => manager.updateUser(data),
+      reloadAuth: () => manager.reloadAuth(),
+      sendVerificationEmail: (email) => manager.sendVerificationEmail(email),
+      sendResetPasswordEmail: (email) => manager.sendResetPasswordEmail(email),
+      resetPassword: (token, newPassword) => manager.resetPassword(token, newPassword),
+      verifyEmail: (otp, email) => manager.verifyEmail(otp, email),
+      exchangeResetPasswordToken: (email, code) => manager.exchangeResetPasswordToken(email, code),
+      loginWithOAuth: (provider, redirectTo) => manager.loginWithOAuth(provider, redirectTo),
+      getPublicAuthConfig: () => manager.getPublicAuthConfig(),
+      // Config
+      baseUrl: manager.getConfig().baseUrl,
+      afterSignInUrl: manager.getConfig().afterSignInUrl || "/"
+    }),
+    [state, manager]
+  );
+  return /* @__PURE__ */ jsx(InsforgeContext.Provider, { value: contextValue, children });
 }
 function InsforgeProvider(props) {
   return /* @__PURE__ */ jsx(NavigationProvider, { adapter: BrowserNavigationAdapter, children: /* @__PURE__ */ jsx(InsforgeProviderCore, { ...props }) });
@@ -431,20 +511,18 @@ function useInsforge() {
       isSignedIn: false,
       setUser: () => {
       },
-      signIn: async () => ({ error: "SSR mode" }),
-      signUp: async () => ({ error: "SSR mode" }),
-      signOut: async () => {
-      },
-      updateUser: async () => ({ error: "SSR mode" }),
-      reloadAuth: async () => ({ success: false, error: "SSR mode" }),
-      sendVerificationEmail: async () => null,
-      sendResetPasswordEmail: async () => null,
-      resetPassword: async () => null,
-      verifyEmail: async () => null,
-      exchangeResetPasswordToken: async () => ({ error: { message: "SSR mode" } }),
-      loginWithOAuth: async () => {
-      },
-      getPublicAuthConfig: async () => null,
+      signIn: () => Promise.resolve({ error: "SSR mode" }),
+      signUp: () => Promise.resolve({ error: "SSR mode" }),
+      signOut: () => Promise.resolve(),
+      updateUser: () => Promise.resolve({ error: "SSR mode" }),
+      reloadAuth: () => Promise.resolve({ success: false, error: "SSR mode" }),
+      sendVerificationEmail: () => Promise.resolve(null),
+      sendResetPasswordEmail: () => Promise.resolve(null),
+      resetPassword: () => Promise.resolve(null),
+      verifyEmail: () => Promise.resolve(null),
+      exchangeResetPasswordToken: () => Promise.resolve({ error: { message: "SSR mode" } }),
+      loginWithOAuth: () => Promise.resolve(),
+      getPublicAuthConfig: () => Promise.resolve(null),
       baseUrl: "",
       afterSignInUrl: "/"
     };
@@ -466,7 +544,7 @@ function usePublicAuthConfig() {
       }
       setIsLoaded(true);
     }
-    fetchConfig();
+    void fetchConfig();
   }, [getPublicAuthConfig]);
   return { authConfig, isLoaded };
 }
@@ -1435,7 +1513,7 @@ function SignIn({ onError, ...uiProps }) {
   }
   function handleOAuth(provider) {
     try {
-      loginWithOAuth(provider, redirectUrl || "");
+      void loginWithOAuth(provider, redirectUrl || "");
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : "OAuth login failed";
       setError(errorMessage);
@@ -1454,7 +1532,7 @@ function SignIn({ onError, ...uiProps }) {
       password,
       onEmailChange: setEmail,
       onPasswordChange: setPassword,
-      onSubmit: handleSubmit,
+      onSubmit: (e) => void handleSubmit(e),
       error,
       loading,
       oauthLoading,
@@ -1712,7 +1790,7 @@ function SignUp({ onError, ...uiProps }) {
   }
   function handleOAuth(provider) {
     try {
-      loginWithOAuth(provider, redirectUrl || "");
+      void loginWithOAuth(provider, redirectUrl || "");
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : "OAuth login failed";
       setError(errorMessage);
@@ -1731,7 +1809,7 @@ function SignUp({ onError, ...uiProps }) {
       password,
       onEmailChange: setEmail,
       onPasswordChange: setPassword,
-      onSubmit: handleSubmit,
+      onSubmit: (e) => void handleSubmit(e),
       error,
       loading,
       oauthLoading,
@@ -2041,7 +2119,7 @@ function ForgotPassword({ onError, ...uiProps }) {
       confirmPassword,
       onNewPasswordChange: setNewPassword,
       onConfirmPasswordChange: setConfirmPassword,
-      onSubmit: handleResetPasswordSubmit,
+      onSubmit: (e) => void handleResetPasswordSubmit(e),
       error,
       loading,
       success,
@@ -2216,7 +2294,7 @@ function ResetPassword({ onError, ...uiProps }) {
       confirmPassword,
       onNewPasswordChange: setNewPassword,
       onConfirmPasswordChange: setConfirmPassword,
-      onSubmit: handleSubmit,
+      onSubmit: (e) => void handleSubmit(e),
       error,
       loading,
       success: false,
@@ -2340,7 +2418,7 @@ function UserButton({ afterSignOutUrl = "/", mode = "detailed" }) {
         setImageError(true);
       }
     };
-    checkImageUrl();
+    void checkImageUrl();
   }, [user?.avatarUrl]);
   useEffect(() => {
     function handleClickOutside(event) {
@@ -2393,7 +2471,7 @@ function UserButton({ afterSignOutUrl = "/", mode = "detailed" }) {
     isOpen && /* @__PURE__ */ jsx("div", { className: "if-userButton-menu", children: /* @__PURE__ */ jsxs(
       "button",
       {
-        onClick: handleSignOut,
+        onClick: () => void handleSignOut(),
         className: "if-userButton-menuItem if-userButton-menuItem-signout",
         children: [
           /* @__PURE__ */ jsx(LogOut, { className: "if-userButton-menuItem-icon" }),