@nextsparkjs/core 0.1.0-beta.188 → 0.1.0-beta.189

package/dist/contexts/TeamContext.js

@@ -9,13 +9,69 @@ import { APP_CONFIG_MERGED } from "../lib/config/config-sync.js";
 import { canUserCreateTeam } from "../lib/teams/helpers.js";
 const TeamContext = createContext(void 0);
 const TEAMS_QUERY_KEY = ["user-teams"];
+const activeTeamCookieWrites = /* @__PURE__ */ new WeakMap();
+const activeTeamCookieRequests = /* @__PURE__ */ new WeakMap();
+const ACTIVE_TEAM_COOKIE_RETRIES = 3;
+const ACTIVE_TEAM_REQUEST_TIMEOUT_MS = 1e4;
+function postActiveTeam(teamId) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), ACTIVE_TEAM_REQUEST_TIMEOUT_MS);
+  return fetch("/api/v1/teams/switch", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ teamId }),
+    signal: controller.signal
+  }).then((response) => response.ok, (error) => {
+    console.error("Failed to sync team cookie:", error);
+    return false;
+  }).finally(() => clearTimeout(timeout));
+}
+function writeActiveTeamCookie(queryClient, sessionKey, teamId) {
+  const key = `${sessionKey}:${teamId}`;
+  const previous = activeTeamCookieWrites.get(queryClient);
+  if ((previous == null ? void 0 : previous.key) === key && !previous.failed) return previous.result;
+  clearTimeout(previous == null ? void 0 : previous.retryTimer);
+  const write = { key, failed: false, result: Promise.resolve(false) };
+  const isCurrent = () => activeTeamCookieWrites.get(queryClient) === write;
+  const attempt = (retry) => {
+    const request = (activeTeamCookieRequests.get(queryClient) ?? Promise.resolve()).then(() => isCurrent() ? postActiveTeam(teamId) : false);
+    activeTeamCookieRequests.set(queryClient, request);
+    return request.then((ok) => {
+      if (ok || !isCurrent()) return ok;
+      if (retry >= ACTIVE_TEAM_COOKIE_RETRIES) {
+        write.failed = true;
+        return false;
+      }
+      return new Promise((resolve) => {
+        write.retryTimer = setTimeout(() => resolve(attempt(retry + 1)), 1e3 * (retry + 1));
+      });
+    });
+  };
+  activeTeamCookieWrites.set(queryClient, write);
+  write.result = attempt(0);
+  return write.result;
+}
+function forgetActiveTeamCookieWrite(queryClient) {
+  var _a;
+  clearTimeout((_a = activeTeamCookieWrites.get(queryClient)) == null ? void 0 : _a.retryTimer);
+  activeTeamCookieWrites.delete(queryClient);
+}
+const MAX_TEAM_PAGES = 50;
 async function fetchUserTeams() {
-  const response = await fetch("/api/v1/teams");
-  const data = await response.json();
-  if (!response.ok || !data.data) {
-    throw new Error("Failed to fetch teams");
+  var _a;
+  const rows = [];
+  for (let page = 1; page <= MAX_TEAM_PAGES; page++) {
+    const response = await fetch(page === 1 ? "/api/v1/teams" : `/api/v1/teams?page=${page}`);
+    const data = await response.json();
+    if (!response.ok || !data.data) {
+      throw new Error("Failed to fetch teams");
+    }
+    rows.push(...data.data);
+    if (!((_a = data.info) == null ? void 0 : _a.hasNextPage) || data.data.length === 0) break;
   }
-  return data.data.map((t) => ({
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueRows = rows.filter((t) => !seen.has(t.id) && Boolean(seen.add(t.id)));
+  return uniqueRows.map((t) => ({
     team: {
       id: t.id,
       name: t.name,
@@ -32,7 +88,9 @@ async function fetchUserTeams() {
   }));
 }
 function TeamProvider({ children }) {
-  const { user, isLoading: authLoading } = useAuth();
+  var _a;
+  const { user, session, isLoading: authLoading } = useAuth();
+  const sessionKey = ((_a = session == null ? void 0 : session.session) == null ? void 0 : _a.id) ?? (user == null ? void 0 : user.id) ?? "";
   const router = useRouter();
   const queryClient = useQueryClient();
   const [currentTeam, setCurrentTeam] = useState(null);
@@ -45,7 +103,9 @@ function TeamProvider({ children }) {
     isLoading: teamsLoading,
     refetch: refetchTeams
   } = useQuery({
-    queryKey: TEAMS_QUERY_KEY,
+    // Per user: the root layout's query client outlives a sign-out that happens
+    // while no TeamProvider is mounted, and one user's teams must not reach the next.
+    queryKey: [...TEAMS_QUERY_KEY, (user == null ? void 0 : user.id) ?? null],
     queryFn: fetchUserTeams,
     enabled: !!user && !authLoading,
     staleTime: 1e3 * 60 * 5,
@@ -69,6 +129,9 @@ function TeamProvider({ children }) {
   }, [userTeams, user]);
   useEffect(() => {
     if (!user) return;
+    const syncCookie = (teamId) => {
+      if (typeof window !== "undefined") void writeActiveTeamCookie(queryClient, sessionKey, teamId);
+    };
     if (!teamsLoading && userTeams.length === 0) {
       if (currentTeam) {
         setCurrentTeam(null);
@@ -79,7 +142,10 @@ function TeamProvider({ children }) {
       return;
     }
     if (!userTeams.length) return;
-    if (currentTeam && userTeams.some((t) => t.team.id === currentTeam.id)) return;
+    if (currentTeam && userTeams.some((t) => t.team.id === currentTeam.id)) {
+      syncCookie(currentTeam.id);
+      return;
+    }
     const storedTeamId = typeof window !== "undefined" ? localStorage.getItem("activeTeamId") : null;
     const storedTeam = storedTeamId ? userTeams.find((t) => t.team.id === storedTeamId) : null;
     const defaultTeam = storedTeam ? void 0 : [...userTeams].sort(
@@ -91,27 +157,24 @@ function TeamProvider({ children }) {
       if (typeof window !== "undefined") {
         localStorage.setItem("activeTeamId", activeTeam.team.id);
       }
-      if (typeof window !== "undefined") {
-        fetch("/api/v1/teams/switch", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ teamId: activeTeam.team.id })
-        }).catch((err) => console.error("Failed to sync team cookie:", err));
-      }
+      syncCookie(activeTeam.team.id);
     }
-  }, [user, userTeams, currentTeam, teamsLoading]);
+  }, [user, userTeams, currentTeam, teamsLoading, queryClient, sessionKey]);
   useEffect(() => {
     if (!user && !authLoading) {
       setCurrentTeam(null);
       if (typeof window !== "undefined") {
         localStorage.removeItem("activeTeamId");
       }
+      forgetActiveTeamCookieWrite(queryClient);
       queryClient.clear();
     }
   }, [user, authLoading, queryClient]);
-  const handleSwitchComplete = useCallback(() => {
+  const handleSwitchComplete = useCallback(async () => {
+    var _a2;
     setSwitchModalOpen(false);
     setIsSwitching(false);
+    await ((_a2 = activeTeamCookieWrites.get(queryClient)) == null ? void 0 : _a2.result);
     queryClient.clear();
     if (typeof window !== "undefined") {
       window.dispatchEvent(new CustomEvent("team-switched", { detail: { teamId: targetTeam == null ? void 0 : targetTeam.id } }));
@@ -136,16 +199,10 @@ function TeamProvider({ children }) {
     if (typeof window !== "undefined") {
       localStorage.setItem("activeTeamId", teamId);
     }
-    try {
-      await fetch("/api/v1/teams/switch", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ teamId })
-      });
-    } catch (error) {
-      console.error("Failed to update team context on server:", error);
+    if (!await writeActiveTeamCookie(queryClient, sessionKey, teamId)) {
+      console.error("Failed to update team context on server");
     }
-  }, [userTeams, currentTeam]);
+  }, [userTeams, currentTeam, queryClient, sessionKey]);
   const refreshTeams = useCallback(async () => {
     await queryClient.invalidateQueries({ queryKey: TEAMS_QUERY_KEY });
     await refetchTeams();

package/dist/emails/otp-verification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"otp-verification.d.ts","sourceRoot":"","sources":["../../src/emails/otp-verification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAKjF,wBAA8B,eAAe,CAC3C,IAAI,EAAE,wBAAwB,EAC9B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,CAAC,CAmEvB"}
+{"version":3,"file":"otp-verification.d.ts","sourceRoot":"","sources":["../../src/emails/otp-verification.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAKjF,wBAA8B,eAAe,CAC3C,IAAI,EAAE,wBAAwB,EAC9B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,CAAC,CAsEvB"}

package/dist/emails/otp-verification.js

@@ -1,10 +1,11 @@
 import { getTranslations } from "next-intl/server";
+import { DEFAULT_OTP_CONFIG } from "../lib/auth/otp-config.js";
 const APP_NAME_FALLBACK = process.env.NEXT_PUBLIC_APP_NAME || "Your App";
-const OTP_EXPIRES_MINUTES = 5;
 async function otpVerification(data, locale) {
   const t = await getTranslations({ locale, namespace: "email.otpVerification" });
   const appName = data.appName || APP_NAME_FALLBACK;
   const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const expiresInMinutes = Math.floor((data.expiresIn ?? DEFAULT_OTP_CONFIG.expiresIn) / 60);
   return {
     subject: t("subject", { otp: data.otp, appName }),
     html: `
@@ -41,7 +42,7 @@ async function otpVerification(data, locale) {
                       </div>
 
                       <p style="color: #999999; font-size: 14px; line-height: 1.6; margin: 0;">
-                        ${t("expiresNotice", { minutes: OTP_EXPIRES_MINUTES })}<br>
+                        ${t("expiresNotice", { minutes: expiresInMinutes })}<br>
                         ${t("ignoreNotice")}
                       </p>
                     </td>

package/dist/hooks/useAccountPreferencesSync.d.ts

@@ -0,0 +1,13 @@
+import type { SessionRefreshContext, SessionRefreshResult } from './useSessionCookieRefresh';
+/**
+ * What to do with each session SessionCookieRefresher reads. Rendering takes
+ * the locale and the theme from the request and configuration alone, so the
+ * account's own choices are applied here:
+ *
+ * - No session: forget the session hint, so public pages stop asking for one.
+ * - A user: keep the hint; make the locale cookie name the account's language,
+ *   refreshing the page when it was rendered in another one; and, in a browser
+ *   where the visitor never chose a theme, apply the one saved to the account.
+ */
+export declare function useAccountPreferencesSync(): (result: SessionRefreshResult, session?: SessionRefreshContext) => void;
+//# sourceMappingURL=useAccountPreferencesSync.d.ts.map

package/dist/hooks/useAccountPreferencesSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAccountPreferencesSync.d.ts","sourceRoot":"","sources":["../../src/hooks/useAccountPreferencesSync.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAoE5F;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,aAIX,oBAAoB,YAAY,qBAAqB,UA4ClF"}

package/dist/hooks/useAccountPreferencesSync.js

@@ -0,0 +1,95 @@
+"use client";
+import { useCallback } from "react";
+import { useRouter } from "next/navigation";
+import { useTheme } from "next-themes";
+import { I18N_CONFIG } from "../lib/config/index.js";
+import { setUserLocaleClient } from "../lib/locale-client.js";
+import { setSessionHint } from "../lib/auth/session-hint.js";
+const THEME_STORAGE_KEY = "theme";
+const THEME_MODES = ["light", "dark", "system"];
+const ACCOUNT_THEME_CHECKED_KEY = "nextspark.account_theme_checked";
+function readCookie(name) {
+  var _a;
+  const prefix = `${name}=`;
+  return (_a = document.cookie.split(";").map((part) => part.trim()).find((part) => part.startsWith(prefix))) == null ? void 0 : _a.slice(prefix.length);
+}
+function hasStoredTheme() {
+  try {
+    return localStorage.getItem(THEME_STORAGE_KEY) !== null;
+  } catch {
+    return true;
+  }
+}
+function claimAccountThemeCheck(userId) {
+  try {
+    if (sessionStorage.getItem(ACCOUNT_THEME_CHECKED_KEY) === userId) return false;
+    sessionStorage.setItem(ACCOUNT_THEME_CHECKED_KEY, userId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const LOCALE_REFRESHED_KEY = "nextspark.locale_refreshed";
+function claimLocaleRefresh(language) {
+  try {
+    if (sessionStorage.getItem(LOCALE_REFRESHED_KEY) === language) return false;
+    sessionStorage.setItem(LOCALE_REFRESHED_KEY, language);
+    return true;
+  } catch {
+    return true;
+  }
+}
+function releaseLocaleRefresh() {
+  try {
+    sessionStorage.removeItem(LOCALE_REFRESHED_KEY);
+  } catch {
+  }
+}
+function releaseAccountThemeCheck(userId) {
+  try {
+    if (sessionStorage.getItem(ACCOUNT_THEME_CHECKED_KEY) === userId) sessionStorage.removeItem(ACCOUNT_THEME_CHECKED_KEY);
+  } catch {
+  }
+}
+function useAccountPreferencesSync() {
+  const router = useRouter();
+  const { setTheme, forcedTheme } = useTheme();
+  return useCallback((result, session) => {
+    var _a;
+    if (!result || result.error) return;
+    const user = (_a = result.data) == null ? void 0 : _a.user;
+    if (!user) {
+      setSessionHint(false);
+      return;
+    }
+    setSessionHint(true);
+    const language = user.language;
+    const localeDetected = I18N_CONFIG.supportedLocales.length > 1 && I18N_CONFIG.localeDetection !== false;
+    if (localeDetected && typeof language === "string" && I18N_CONFIG.supportedLocales.includes(language)) {
+      if (readCookie(I18N_CONFIG.cookie.name) !== language) setUserLocaleClient(language);
+      if (document.documentElement.lang === language) {
+        releaseLocaleRefresh();
+      } else if (readCookie(I18N_CONFIG.cookie.name) === language && claimLocaleRefresh(language)) {
+        router.refresh();
+      }
+    }
+    const userId = typeof user.id === "string" ? user.id : "signed-in";
+    if (!forcedTheme && !hasStoredTheme() && claimAccountThemeCheck(userId)) {
+      fetch("/api/user/profile?includeMeta=true").then((response) => {
+        if (!response.ok) throw new Error(`Profile request failed with status ${response.status}`);
+        return response.json();
+      }).then((profile) => {
+        var _a2, _b;
+        if (session && !session.isCurrent()) {
+          releaseAccountThemeCheck(userId);
+          return;
+        }
+        const theme = (_b = (_a2 = profile == null ? void 0 : profile.meta) == null ? void 0 : _a2.uiPreferences) == null ? void 0 : _b.theme;
+        if (THEME_MODES.includes(theme)) setTheme(theme);
+      }).catch(() => releaseAccountThemeCheck(userId));
+    }
+  }, [router, setTheme, forcedTheme]);
+}
+export {
+  useAccountPreferencesSync
+};

package/dist/hooks/useAuth.d.ts

@@ -1,7 +1,27 @@
 import type { SessionUser } from '../lib/auth';
-export declare function useAuth(): {
-    user: SessionUser | null;
-    session: {
+/**
+ * Sign-in, sign-up and account actions, without subscribing to the session: a
+ * page that only acts, like the login and signup forms, makes no session request.
+ */
+export declare function useAuthActions(): {
+    signIn: ({ email, password, redirectTo }: {
+        email: string;
+        password: string;
+        redirectTo?: string;
+    }) => Promise<Omit<{
+        redirect: boolean;
+        token: string;
+        url?: string | undefined;
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
         user: import("better-auth").StripEmptyObjects<{
             id: string;
             createdAt: Date;
@@ -11,18 +31,166 @@ export declare function useAuth(): {
             email?: string;
             image?: string;
         } & {} & {}>;
-        session: import("better-auth").StripEmptyObjects<{
+    }>;
+    signUp: ({ email, password, firstName, lastName, intent }: {
+        email: string;
+        password: string;
+        firstName?: string;
+        lastName?: string;
+        intent?: string;
+    }) => Promise<(Omit<{
+        token: null;
+        user: {
             id: string;
             createdAt: Date;
             updatedAt: Date;
-            userId: string;
-            expiresAt: Date;
-            token: string;
-            ipAddress?: string;
-            userAgent?: string;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
         } & {} & {}>;
-    };
-    isLoading: boolean;
+    }) | (Omit<{
+        token: string;
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    })>;
+    signOut: () => Promise<void>;
+    googleSignIn: (redirectTo?: string) => Promise<void>;
+    sendOtp: (email: string) => Promise<{
+        success: boolean;
+    }>;
+    signInWithOtp: ({ email, otp, redirectTo }: {
+        email: string;
+        otp: string;
+        redirectTo?: string;
+    }) => Promise<Omit<{
+        token: string;
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    }, "user"> & {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+    }>;
+    resetPassword: (email: string) => Promise<{
+        success: boolean;
+        data: any;
+        error: string;
+    } | {
+        success: boolean;
+        data: {
+            status: boolean;
+            message: string;
+        };
+        error: any;
+    }>;
+    updatePassword: (newPassword: string, token?: string) => Promise<{
+        success: boolean;
+        data: any;
+        error: string;
+    } | {
+        success: boolean;
+        data: {
+            status: boolean;
+        };
+        error: any;
+    }>;
+    changePassword: (currentPassword: string, newPassword: string, revokeOtherSessions?: boolean) => Promise<{
+        success: boolean;
+        data: any;
+        error: string;
+    } | {
+        success: boolean;
+        data: Omit<{
+            token: string | null;
+            user: {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            } & Record<string, any> & {
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                email: string;
+                emailVerified: boolean;
+                name: string;
+                image?: string | null | undefined;
+            };
+        }, "user"> & {
+            user: import("better-auth").StripEmptyObjects<{
+                id: string;
+                createdAt: Date;
+                updatedAt: Date;
+                emailVerified: boolean;
+                name: string;
+                email?: string;
+                image?: string;
+            } & {} & {}>;
+        };
+        error: any;
+    }>;
+    resendVerificationEmail: (email: string) => Promise<{
+        success: boolean;
+        data: any;
+        error: string;
+    } | {
+        success: boolean;
+        data: {
+            status: boolean;
+        };
+        error: any;
+    }>;
+};
+/** The session (user, loading state) and the auth actions. */
+export declare function useAuth(): {
+    isSigningIn: boolean;
+    isSigningUp: boolean;
+    signInError: any;
+    signUpError: any;
     signIn: ({ email, password, redirectTo }: {
         email: string;
         password: string;
@@ -203,9 +371,28 @@ export declare function useAuth(): {
         };
         error: any;
     }>;
-    isSigningIn: boolean;
-    isSigningUp: boolean;
-    signInError: any;
-    signUpError: any;
+    user: SessionUser | null;
+    session: {
+        user: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            emailVerified: boolean;
+            name: string;
+            email?: string;
+            image?: string;
+        } & {} & {}>;
+        session: import("better-auth").StripEmptyObjects<{
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string;
+            userAgent?: string;
+        } & {} & {}>;
+    };
+    isLoading: boolean;
 };
 //# sourceMappingURL=useAuth.d.ts.map

package/dist/hooks/useAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAS9C,wBAAgB,OAAO;UA4OS,WAAW,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;8CAtOa;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;+DAmBvC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAuE1H,MAAM;qBAhCjB,MAAM;;;gDAgBiB;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;iBA8Kyf,CAAC;;;;;;;;;;;;;2BAlJ9jB,MAAM;;;;;;;;;;;;kCA6BC,MAAM,UAAU,MAAM;;;;;;;;;;;sCAwClB,MAAM,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA8B5B,MAAM;;;;;;;;;;;;;;;EA+C3D"}
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AA0C9C;;;GAGG;AACH,wBAAgB,cAAc;8CAYiC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;+DAqBvC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA2E1H,MAAM;qBAlCjB,MAAM;;;gDAgBiB;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;iBA4G3D,CAAC;;;;;;;;;;;;;2BAjFV,MAAM;;;;;;;;;;;;kCA6BC,MAAM,UAAU,MAAM;;;;;;;;;;;sCAwClB,MAAM,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA8B5B,MAAM;;;;;;;;;;;EAwC3D;AAED,8DAA8D;AAC9D,wBAAgB,OAAO;;;;;8CAvPwC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;+DAqBvC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA2E1H,MAAM;qBAlCjB,MAAM;;;gDAgBiB;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;iBA4G3D,CAAC;;;;;;;;;;;;;2BAjFV,MAAM;;;;;;;;;;;;kCA6BC,MAAM,UAAU,MAAM;;;;;;;;;;;sCAwClB,MAAM,eAAe,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA8B5B,MAAM;;;;;;;;;;;UAqD5B,WAAW,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;EASjD"}

package/dist/hooks/useAuth.js

@@ -1,25 +1,46 @@
 "use client";
+import { useContext, useEffect } from "react";
 import { useRouter } from "next/navigation";
+import { QueryClientContext } from "@tanstack/react-query";
 import { authClient } from "../lib/auth-client.js";
 import { useOrigin } from "./useOrigin.js";
 import { useLastAuthMethod } from "./useLastAuthMethod.js";
-function useAuth() {
-  var _a;
+import { safeCallbackPath } from "../lib/auth/callback-url.js";
+import { setSessionHint } from "../lib/auth/session-hint.js";
+import { setUserLocaleClient } from "../lib/locale-client.js";
+import { I18N_CONFIG } from "../lib/config/index.js";
+function googleCallbackURL(redirectTo) {
+  const url = new URL(safeCallbackPath(redirectTo) ?? "/dashboard", "http://callback.invalid");
+  url.searchParams.set("auth_method", "google");
+  return `${url.pathname}${url.search.replace(/\*/g, "%2A")}`;
+}
+function rememberSignedIn(user) {
+  setSessionHint(true);
+  const language = user == null ? void 0 : user.language;
+  const localeDetected = I18N_CONFIG.supportedLocales.length > 1 && I18N_CONFIG.localeDetection !== false;
+  if (localeDetected && typeof language === "string" && I18N_CONFIG.supportedLocales.includes(language)) {
+    setUserLocaleClient(language);
+  }
+}
+function useAuthActions() {
   const router = useRouter();
-  const session = authClient.useSession();
   const origin = useOrigin();
   const { saveAuthMethod } = useLastAuthMethod();
+  const queryClient = useContext(QueryClientContext);
+  const forgetSignedInData = () => queryClient == null ? void 0 : queryClient.clear();
   const handleSignIn = async ({ email, password, redirectTo }) => {
     const { data, error } = await authClient.signIn.email({
       email,
       password
     });
     if (error) {
-      throw new Error(error.message || "Error al iniciar sesi\xF3n");
+      throw new Error(error.message || "Failed to sign in");
     }
     if (data) {
       saveAuthMethod("email");
-      router.push(redirectTo || "/dashboard");
+      forgetSignedInData();
+      rememberSignedIn(data.user);
+      router.push(safeCallbackPath(redirectTo) ?? "/dashboard");
     }
     return data;
   };
@@ -47,6 +68,8 @@ function useAuth() {
       localStorage.removeItem("activeTeamId");
     }
     await authClient.signOut();
+    setSessionHint(false);
+    forgetSignedInData();
     router.push("/login");
   };
   const handleSendOtp = async (email) => {
@@ -66,15 +89,16 @@ function useAuth() {
     }
     if (data) {
       saveAuthMethod("email");
-      router.push(redirectTo || "/dashboard");
+      forgetSignedInData();
+      rememberSignedIn(data.user);
+      router.push(safeCallbackPath(redirectTo) ?? "/dashboard");
     }
     return data;
   };
   const handleGoogleSignIn = async (redirectTo) => {
-    const callbackURL = redirectTo ? `${redirectTo}${redirectTo.includes("?") ? "&" : "?"}auth_method=google` : "/dashboard?auth_method=google";
     await authClient.signIn.social({
       provider: "google",
-      callbackURL
+      callbackURL: googleCallbackURL(redirectTo)
     });
   };
   const handleResetPassword = async (email) => {
@@ -189,9 +213,6 @@ function useAuth() {
     }
   };
   return {
-    user: (_a = session.data) == null ? void 0 : _a.user,
-    session: session.data,
-    isLoading: session.isPending,
     signIn: handleSignIn,
     signUp: handleSignUp,
     signOut: handleSignOut,
@@ -201,7 +222,21 @@ function useAuth() {
     resetPassword: handleResetPassword,
     updatePassword: handleUpdatePassword,
     changePassword: handleChangePassword,
-    resendVerificationEmail: handleResendVerificationEmail,
+    resendVerificationEmail: handleResendVerificationEmail
+  };
+}
+function useAuth() {
+  var _a;
+  const session = authClient.useSession();
+  const actions = useAuthActions();
+  useEffect(() => {
+    if (!session.isPending && !session.error) setSessionHint(Boolean(session.data));
+  }, [session.isPending, session.error, session.data]);
+  return {
+    user: (_a = session.data) == null ? void 0 : _a.user,
+    session: session.data,
+    isLoading: session.isPending,
+    ...actions,
     isSigningIn: false,
     // BetterAuth doesn't provide this directly
     isSigningUp: false,
@@ -211,5 +246,6 @@ function useAuth() {
   };
 }
 export {
-  useAuth
+  useAuth,
+  useAuthActions
 };