@instroc/auth 1.0.1 → 1.1.0

package/dist/chunk-GV63J77S.js

@@ -0,0 +1,935 @@
+// src/forms/use-login-form.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
+
+// src/provider.tsx
+import {
+  createContext,
+  useContext,
+  useState,
+  useCallback,
+  useEffect,
+  useRef
+} from "react";
+
+// src/errors.ts
+var AuthError = class _AuthError extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "AuthError";
+    this.status = status;
+    this.code = code;
+    Object.setPrototypeOf(this, _AuthError.prototype);
+  }
+};
+function authErrorFromResponse(response, data, fallbackMessage) {
+  const body = data ?? {};
+  const message = body.error || fallbackMessage;
+  return new AuthError(message, response.status, body.code);
+}
+
+// src/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+var STORAGE_KEY = "instroc_auth_session";
+function AuthProvider({
+  children,
+  projectId: initialProjectId,
+  baseUrl = "/api/baas",
+  persistSession = true,
+  onAuthStateChange
+}) {
+  const [projectId, setProjectId] = useState(
+    initialProjectId || null
+  );
+  const [user, setUser] = useState(null);
+  const [session, setSession] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [authConfig, setAuthConfig] = useState(null);
+  const [visibilityConfig, setVisibilityConfig] = useState(null);
+  const refreshTimeoutRef = useRef(null);
+  const buildUrl = useCallback(
+    (endpoint) => {
+      if (!projectId) {
+        throw new Error("Project ID is required");
+      }
+      return `${baseUrl}/${projectId}/auth/${endpoint}`;
+    },
+    [projectId, baseUrl]
+  );
+  const authFetch = useCallback(
+    (url, init) => fetch(url, { ...init, credentials: "include" }),
+    []
+  );
+  const saveSession = useCallback(
+    (sessionData) => {
+      if (persistSession && typeof window !== "undefined") {
+        if (sessionData) {
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(sessionData));
+        } else {
+          localStorage.removeItem(STORAGE_KEY);
+        }
+      }
+    },
+    [persistSession]
+  );
+  const loadSession = useCallback(() => {
+    if (persistSession && typeof window !== "undefined") {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        try {
+          return JSON.parse(stored);
+        } catch {
+          localStorage.removeItem(STORAGE_KEY);
+        }
+      }
+    }
+    return null;
+  }, [persistSession]);
+  const scheduleRefresh = useCallback(
+    (expiresAt) => {
+      if (refreshTimeoutRef.current) {
+        clearTimeout(refreshTimeoutRef.current);
+      }
+      const expiresTime = new Date(expiresAt).getTime();
+      const now = Date.now();
+      const refreshIn = expiresTime - now - 5 * 60 * 1e3;
+      if (refreshIn > 0) {
+        refreshTimeoutRef.current = setTimeout(async () => {
+          try {
+            await refreshSession();
+          } catch (err) {
+            console.warn("Token refresh failed:", err);
+            setUser(null);
+            setSession(null);
+            saveSession(null);
+          }
+        }, refreshIn);
+      }
+    },
+    [saveSession]
+  );
+  const updateAuthState = useCallback(
+    (newUser, newSession) => {
+      setUser(newUser);
+      setSession(newSession);
+      saveSession(newSession);
+      if (newSession) {
+        scheduleRefresh(newSession.expires_at);
+      }
+      if (onAuthStateChange) {
+        onAuthStateChange(newUser);
+      }
+    },
+    [saveSession, scheduleRefresh, onAuthStateChange]
+  );
+  const fetchUser = useCallback(async () => {
+    const storedSession = loadSession();
+    if (!storedSession || !projectId) {
+      setLoading(false);
+      return;
+    }
+    try {
+      const response = await authFetch(buildUrl("me"), {
+        headers: {
+          Authorization: `Bearer ${storedSession.access_token}`
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        updateAuthState(data.user, storedSession);
+      } else if (response.status === 401) {
+        try {
+          const refreshResponse = await authFetch(buildUrl("refresh"), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ refreshToken: storedSession.refresh_token })
+          });
+          if (refreshResponse.ok) {
+            const refreshData = await refreshResponse.json();
+            const newSession = {
+              ...storedSession,
+              access_token: refreshData.access_token,
+              expires_at: refreshData.expires_at
+            };
+            const userResponse = await authFetch(buildUrl("me"), {
+              headers: {
+                Authorization: `Bearer ${newSession.access_token}`
+              }
+            });
+            if (userResponse.ok) {
+              const userData = await userResponse.json();
+              updateAuthState(userData.user, newSession);
+            } else {
+              updateAuthState(null, null);
+            }
+          } else {
+            updateAuthState(null, null);
+          }
+        } catch {
+          updateAuthState(null, null);
+        }
+      } else {
+        updateAuthState(null, null);
+      }
+    } catch (err) {
+      console.error("Failed to fetch user:", err);
+      updateAuthState(null, null);
+    } finally {
+      setLoading(false);
+    }
+  }, [projectId, loadSession, buildUrl, updateAuthState]);
+  useEffect(() => {
+    if (projectId) {
+      fetchUser();
+    } else {
+      setLoading(false);
+    }
+    return () => {
+      if (refreshTimeoutRef.current) {
+        clearTimeout(refreshTimeoutRef.current);
+      }
+    };
+  }, [projectId, fetchUser]);
+  const login = useCallback(
+    async (credentials) => {
+      setError(null);
+      setLoading(true);
+      try {
+        const response = await authFetch(buildUrl("login"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(credentials)
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Login failed");
+        }
+        const authResponse = data;
+        updateAuthState(authResponse.user, authResponse.session);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Login failed";
+        setError(message);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [buildUrl, updateAuthState]
+  );
+  const signup = useCallback(
+    async (credentials) => {
+      setError(null);
+      setLoading(true);
+      try {
+        const response = await authFetch(buildUrl("signup"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(credentials)
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Signup failed");
+        }
+        const authResponse = data;
+        if (authResponse.needsVerification) {
+          return {
+            status: "needs_verification",
+            email: credentials.email
+          };
+        }
+        if (authResponse.needsApproval) {
+          updateAuthState(authResponse.user, authResponse.session);
+          return { status: "needs_approval", user: authResponse.user };
+        }
+        if (authResponse.session.access_token) {
+          updateAuthState(authResponse.user, authResponse.session);
+          return { status: "authenticated", user: authResponse.user };
+        }
+        return {
+          status: "needs_verification",
+          email: credentials.email
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Signup failed";
+        setError(message);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [buildUrl, updateAuthState]
+  );
+  const logout = useCallback(async () => {
+    try {
+      if (session) {
+        await authFetch(buildUrl("logout"), {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${session.access_token}`
+          }
+        });
+      }
+    } catch (err) {
+      console.error("Logout error:", err);
+    } finally {
+      updateAuthState(null, null);
+      if (refreshTimeoutRef.current) {
+        clearTimeout(refreshTimeoutRef.current);
+      }
+    }
+  }, [session, buildUrl, updateAuthState]);
+  const updateProfile = useCallback(
+    async (data) => {
+      if (!session) {
+        throw new AuthError("Not authenticated", 401);
+      }
+      setError(null);
+      try {
+        const response = await authFetch(buildUrl("me"), {
+          method: "PATCH",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${session.access_token}`
+          },
+          body: JSON.stringify(data)
+        });
+        const result = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, result, "Update failed");
+        }
+        setUser(result.user);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Update failed";
+        setError(message);
+        throw err;
+      }
+    },
+    [session, buildUrl]
+  );
+  const refreshSession = useCallback(async () => {
+    if (!session)
+      return;
+    const response = await authFetch(buildUrl("refresh"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken: session.refresh_token })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw authErrorFromResponse(response, data, "Refresh failed");
+    }
+    const refreshData = data;
+    const newSession = {
+      ...session,
+      access_token: refreshData.access_token,
+      expires_at: refreshData.expires_at
+    };
+    updateAuthState(user, newSession);
+  }, [session, user, buildUrl, updateAuthState]);
+  const forgotPassword = useCallback(
+    async (email) => {
+      setError(null);
+      try {
+        const response = await authFetch(buildUrl("forgot-password"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Request failed");
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Request failed";
+        setError(message);
+        throw err;
+      }
+    },
+    [buildUrl]
+  );
+  const resetPassword = useCallback(
+    async (token, newPassword) => {
+      setError(null);
+      try {
+        const response = await authFetch(buildUrl("reset-password"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ token, password: newPassword })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Reset failed");
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Reset failed";
+        setError(message);
+        throw err;
+      }
+    },
+    [buildUrl]
+  );
+  const signInWithOAuth = useCallback(
+    (provider) => {
+      if (!projectId) {
+        setError("Project ID is required");
+        return;
+      }
+      const currentUrl = window.location.origin + window.location.pathname;
+      const oauthUrl = `${baseUrl}/${projectId}/auth/oauth/${provider}?redirect_uri=${encodeURIComponent(currentUrl)}`;
+      window.location.href = oauthUrl;
+    },
+    [projectId, baseUrl]
+  );
+  const verifyOTP = useCallback(
+    async (email, code) => {
+      setError(null);
+      setLoading(true);
+      try {
+        const response = await authFetch(buildUrl("verify-email"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email, otp: code })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Verification failed");
+        }
+        if (data.session) {
+          updateAuthState(data.user, data.session);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Verification failed";
+        setError(message);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [buildUrl, updateAuthState]
+  );
+  const resendOTP = useCallback(
+    async (email) => {
+      setError(null);
+      try {
+        const response = await authFetch(buildUrl("resend-verification"), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ email })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          throw authErrorFromResponse(response, data, "Failed to resend code");
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to resend code";
+        setError(message);
+        throw err;
+      }
+    },
+    [buildUrl]
+  );
+  const fetchAuthConfig = useCallback(async () => {
+    if (!projectId)
+      return;
+    try {
+      const response = await fetch(`${baseUrl}/${projectId}/auth/config`);
+      if (response.ok) {
+        const data = await response.json();
+        setAuthConfig(data.config || null);
+        setVisibilityConfig(
+          data.visibility || {
+            projectName: "App",
+            visibility: "public",
+            requireLogin: false,
+            logoUrl: null,
+            welcomeMessage: null
+          }
+        );
+      }
+    } catch (err) {
+      console.error("Failed to fetch auth config:", err);
+    }
+  }, [projectId, baseUrl]);
+  const parseOAuthCallback = useCallback(() => {
+    if (typeof window === "undefined")
+      return;
+    const hash = window.location.hash;
+    if (hash && hash.startsWith("#auth=")) {
+      try {
+        const authData = decodeURIComponent(hash.substring(6));
+        const tokenData = JSON.parse(authData);
+        if (tokenData.access_token && tokenData.refresh_token) {
+          const newSession = {
+            access_token: tokenData.access_token,
+            refresh_token: tokenData.refresh_token,
+            expires_at: tokenData.expires_at
+          };
+          saveSession(newSession);
+          setSession(newSession);
+          window.history.replaceState({}, "", window.location.pathname);
+          return true;
+        }
+      } catch {
+      }
+    }
+    const params = new URLSearchParams(window.location.search);
+    const verifyEmailToken = params.get("verify_email");
+    if (verifyEmailToken && projectId) {
+      fetch(buildUrl("verify-email"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token: verifyEmailToken })
+      }).then((res) => res.json()).then(() => {
+        window.history.replaceState({}, "", window.location.pathname);
+      }).catch(() => {
+        window.history.replaceState({}, "", window.location.pathname);
+      });
+      return true;
+    }
+    const accessToken = params.get("access_token");
+    const refreshToken = params.get("refresh_token");
+    const expiresAt = params.get("expires_at");
+    if (accessToken && refreshToken && expiresAt) {
+      const newSession = {
+        access_token: accessToken,
+        refresh_token: refreshToken,
+        expires_at: expiresAt
+      };
+      saveSession(newSession);
+      setSession(newSession);
+      window.history.replaceState({}, "", window.location.pathname);
+      return true;
+    }
+    return false;
+  }, [projectId, buildUrl, saveSession]);
+  useEffect(() => {
+    fetchAuthConfig();
+  }, [fetchAuthConfig]);
+  useEffect(() => {
+    parseOAuthCallback();
+  }, [parseOAuthCallback]);
+  const value = {
+    user,
+    session,
+    loading,
+    error,
+    login,
+    signup,
+    logout,
+    signInWithOAuth,
+    verifyOTP,
+    resendOTP,
+    updateProfile,
+    refreshSession,
+    forgotPassword,
+    resetPassword,
+    setProjectId,
+    projectId,
+    authConfig,
+    visibilityConfig
+  };
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value, children });
+}
+function useAuthContext() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuthContext must be used within an AuthProvider");
+  }
+  return context;
+}
+
+// src/use-auth.ts
+function useAuth() {
+  return useAuthContext();
+}
+function useUser() {
+  const { user, loading } = useAuthContext();
+  return { user, loading };
+}
+function useSession() {
+  const { session, loading } = useAuthContext();
+  return { session, loading };
+}
+function useAuthRequired() {
+  const { user, loading, session } = useAuthContext();
+  if (loading) {
+    return { user: null, session: null, loading: true };
+  }
+  if (!user) {
+    throw new Error("Authentication required");
+  }
+  return { user, session, loading: false };
+}
+
+// src/forms/use-form-action.ts
+function resolveErrorMessage(err, messages, fallback) {
+  if (err instanceof AuthError) {
+    return messages?.[err.status] ?? err.message ?? fallback;
+  }
+  if (err instanceof Error)
+    return err.message;
+  return fallback;
+}
+function applyErrorResult(err, onError, messages, fallback, setError) {
+  const override = onError?.(err);
+  if (override === null) {
+    setError(null);
+    return;
+  }
+  if (typeof override === "string") {
+    setError(override);
+    return;
+  }
+  setError(resolveErrorMessage(err, messages, fallback));
+}
+
+// src/forms/use-login-form.ts
+function useLoginForm(options = {}) {
+  const { login, user } = useAuth();
+  const { onSuccess, onNeedsVerification, onError, messages } = options;
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const mountedRef = useRef2(true);
+  useEffect2(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetError = useCallback2((msg) => {
+    if (mountedRef.current)
+      setError(msg);
+  }, []);
+  const clearError = useCallback2(() => safeSetError(null), [safeSetError]);
+  const submit = useCallback2(
+    async (credentials) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        await login(credentials);
+        onSuccess?.(user ?? { id: "", email: credentials.email });
+      } catch (err) {
+        if (err instanceof AuthError && err.status === 403 && onNeedsVerification) {
+          safeSetError(null);
+          onNeedsVerification(credentials.email);
+          return;
+        }
+        applyErrorResult(
+          err,
+          onError,
+          messages,
+          "Login failed. Please try again.",
+          safeSetError
+        );
+      } finally {
+        if (mountedRef.current)
+          setLoading(false);
+      }
+    },
+    [
+      login,
+      user,
+      onSuccess,
+      onNeedsVerification,
+      onError,
+      messages,
+      safeSetError
+    ]
+  );
+  return { submit, loading, error, setError: safeSetError, clearError };
+}
+
+// src/forms/use-signup-form.ts
+import { useState as useState3, useCallback as useCallback3, useRef as useRef3, useEffect as useEffect3 } from "react";
+function useSignupForm(options = {}) {
+  const { signup } = useAuth();
+  const { onSuccess, onNeedsVerification, onNeedsApproval, onError, messages } = options;
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const mountedRef = useRef3(true);
+  useEffect3(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetError = useCallback3((msg) => {
+    if (mountedRef.current)
+      setError(msg);
+  }, []);
+  const clearError = useCallback3(() => safeSetError(null), [safeSetError]);
+  const submit = useCallback3(
+    async (credentials) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        const result = await signup(credentials);
+        switch (result.status) {
+          case "authenticated":
+            onSuccess?.(result.user);
+            return;
+          case "needs_verification":
+            onNeedsVerification?.(result.email);
+            return;
+          case "needs_approval":
+            onNeedsApproval?.(result.user);
+            return;
+        }
+      } catch (err) {
+        applyErrorResult(
+          err,
+          onError,
+          messages,
+          "Signup failed. Please try again.",
+          safeSetError
+        );
+      } finally {
+        if (mountedRef.current)
+          setLoading(false);
+      }
+    },
+    [
+      signup,
+      onSuccess,
+      onNeedsVerification,
+      onNeedsApproval,
+      onError,
+      messages,
+      safeSetError
+    ]
+  );
+  return { submit, loading, error, setError: safeSetError, clearError };
+}
+
+// src/forms/use-otp-form.ts
+import { useState as useState4, useCallback as useCallback4, useRef as useRef4, useEffect as useEffect4 } from "react";
+function useOtpForm(options) {
+  const { verifyOTP, resendOTP } = useAuth();
+  const {
+    email,
+    onSuccess,
+    onResendSuccess,
+    onError,
+    messages,
+    resendCooldownSeconds = 60
+  } = options;
+  const [loading, setLoading] = useState4(false);
+  const [resending, setResending] = useState4(false);
+  const [resendCooldown, setResendCooldown] = useState4(0);
+  const [error, setError] = useState4(null);
+  const mountedRef = useRef4(true);
+  useEffect4(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  useEffect4(() => {
+    if (resendCooldown <= 0)
+      return;
+    const id = setTimeout(() => setResendCooldown((s) => s - 1), 1e3);
+    return () => clearTimeout(id);
+  }, [resendCooldown]);
+  const safeSetError = useCallback4((msg) => {
+    if (mountedRef.current)
+      setError(msg);
+  }, []);
+  const clearError = useCallback4(() => safeSetError(null), [safeSetError]);
+  const submit = useCallback4(
+    async (code) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        await verifyOTP(email, code);
+        onSuccess?.();
+      } catch (err) {
+        applyErrorResult(
+          err,
+          onError,
+          messages,
+          "Verification failed. Please try again.",
+          safeSetError
+        );
+      } finally {
+        if (mountedRef.current)
+          setLoading(false);
+      }
+    },
+    [verifyOTP, email, onSuccess, onError, messages, safeSetError]
+  );
+  const resend = useCallback4(async () => {
+    if (resendCooldown > 0)
+      return;
+    if (mountedRef.current) {
+      setResending(true);
+      setError(null);
+    }
+    try {
+      await resendOTP(email);
+      if (mountedRef.current)
+        setResendCooldown(resendCooldownSeconds);
+      onResendSuccess?.();
+    } catch (err) {
+      applyErrorResult(
+        err,
+        onError,
+        messages,
+        "Could not resend code. Please try again.",
+        safeSetError
+      );
+    } finally {
+      if (mountedRef.current)
+        setResending(false);
+    }
+  }, [
+    resendCooldown,
+    resendOTP,
+    email,
+    resendCooldownSeconds,
+    onResendSuccess,
+    onError,
+    messages,
+    safeSetError
+  ]);
+  return {
+    submit,
+    resend,
+    loading,
+    resending,
+    resendCooldown,
+    error,
+    setError: safeSetError,
+    clearError
+  };
+}
+
+// src/forms/use-forgot-password-form.ts
+import { useState as useState5, useCallback as useCallback5, useRef as useRef5, useEffect as useEffect5 } from "react";
+function useForgotPasswordForm(options = {}) {
+  const { forgotPassword } = useAuth();
+  const { onSuccess, onError, messages } = options;
+  const [loading, setLoading] = useState5(false);
+  const [submitted, setSubmitted] = useState5(false);
+  const [error, setError] = useState5(null);
+  const mountedRef = useRef5(true);
+  useEffect5(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetError = useCallback5((msg) => {
+    if (mountedRef.current)
+      setError(msg);
+  }, []);
+  const clearError = useCallback5(() => safeSetError(null), [safeSetError]);
+  const reset = useCallback5(() => {
+    if (mountedRef.current) {
+      setSubmitted(false);
+      setError(null);
+    }
+  }, []);
+  const submit = useCallback5(
+    async (email) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        await forgotPassword(email);
+        if (mountedRef.current)
+          setSubmitted(true);
+        onSuccess?.(email);
+      } catch (err) {
+        applyErrorResult(
+          err,
+          onError,
+          messages,
+          "Could not send reset link. Please try again.",
+          safeSetError
+        );
+      } finally {
+        if (mountedRef.current)
+          setLoading(false);
+      }
+    },
+    [forgotPassword, onSuccess, onError, messages, safeSetError]
+  );
+  return {
+    submit,
+    loading,
+    submitted,
+    error,
+    setError: safeSetError,
+    clearError,
+    reset
+  };
+}
+
+// src/forms/use-reset-password-form.ts
+import { useState as useState6, useCallback as useCallback6, useRef as useRef6, useEffect as useEffect6 } from "react";
+function useResetPasswordForm(options) {
+  const { resetPassword } = useAuth();
+  const { token, onSuccess, onError, messages } = options;
+  const [loading, setLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const mountedRef = useRef6(true);
+  useEffect6(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const safeSetError = useCallback6((msg) => {
+    if (mountedRef.current)
+      setError(msg);
+  }, []);
+  const clearError = useCallback6(() => safeSetError(null), [safeSetError]);
+  const submit = useCallback6(
+    async (newPassword) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        await resetPassword(token, newPassword);
+        onSuccess?.();
+      } catch (err) {
+        applyErrorResult(
+          err,
+          onError,
+          messages,
+          "Could not reset password. Please try again.",
+          safeSetError
+        );
+      } finally {
+        if (mountedRef.current)
+          setLoading(false);
+      }
+    },
+    [resetPassword, token, onSuccess, onError, messages, safeSetError]
+  );
+  return { submit, loading, error, setError: safeSetError, clearError };
+}
+
+export {
+  AuthError,
+  AuthProvider,
+  useAuthContext,
+  useAuth,
+  useUser,
+  useSession,
+  useAuthRequired,
+  useLoginForm,
+  useSignupForm,
+  useOtpForm,
+  useForgotPasswordForm,
+  useResetPasswordForm
+};