@djangocfg/api 2.1.46 → 2.1.48

package/dist/auth.cjs

@@ -62,7 +62,7 @@ module.exports = __toCommonJS(auth_exports);
 
 // src/auth/context/AuthContext.tsx
 var import_navigation = require("next/navigation");
-var import_react2 = require("react");
+var import_react3 = require("react");
 var import_hooks2 = require("@djangocfg/ui-nextjs/hooks");
 
 // src/generated/cfg_accounts/accounts__auth/client.ts
@@ -3717,6 +3717,185 @@ function getCacheMetadata() {
 }
 __name(getCacheMetadata, "getCacheMetadata");
 
+// src/auth/hooks/useSessionStorage.ts
+var import_react = require("react");
+function useSessionStorage(key, initialValue) {
+  const [storedValue, setStoredValue] = (0, import_react.useState)(() => {
+    if (typeof window === "undefined") {
+      return initialValue;
+    }
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      authLogger.error(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+  const checkDataSize = /* @__PURE__ */ __name((data) => {
+    try {
+      const jsonString = JSON.stringify(data);
+      const sizeInBytes = new Blob([jsonString]).size;
+      const sizeInKB = sizeInBytes / 1024;
+      if (sizeInKB > 1024) {
+        authLogger.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      authLogger.error(`Error checking data size for key "${key}":`, error);
+      return false;
+    }
+  }, "checkDataSize");
+  const clearOldData = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(sessionStorage).filter((key2) => key2 && typeof key2 === "string");
+      if (keys.length > 50) {
+        const itemsToRemove = Math.ceil(keys.length * 0.2);
+        for (let i = 0; i < itemsToRemove; i++) {
+          try {
+            const key2 = keys[i];
+            if (key2) {
+              sessionStorage.removeItem(key2);
+              sessionStorage.removeItem(`${key2}_timestamp`);
+            }
+          } catch {
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error("Error clearing old sessionStorage data:", error);
+    }
+  }, "clearOldData");
+  const forceClearAll = /* @__PURE__ */ __name(() => {
+    try {
+      const keys = Object.keys(sessionStorage);
+      for (const key2 of keys) {
+        try {
+          sessionStorage.removeItem(key2);
+        } catch {
+        }
+      }
+    } catch (error) {
+      authLogger.error("Error force clearing sessionStorage:", error);
+    }
+  }, "forceClearAll");
+  const setValue = /* @__PURE__ */ __name((value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      if (!checkDataSize(valueToStore)) {
+        authLogger.warn(`Data size too large for key "${key}", removing key`);
+        try {
+          window.sessionStorage.removeItem(key);
+          window.sessionStorage.removeItem(`${key}_timestamp`);
+        } catch {
+        }
+        setStoredValue(valueToStore);
+        return;
+      }
+      setStoredValue(valueToStore);
+      if (typeof window !== "undefined") {
+        try {
+          window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+          window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+        } catch (storageError) {
+          if (storageError.name === "QuotaExceededError" || storageError.code === 22 || storageError.message?.includes("quota")) {
+            authLogger.warn("sessionStorage quota exceeded, clearing old data...");
+            clearOldData();
+            try {
+              window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+              window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+            } catch (retryError) {
+              authLogger.error(`Failed to set sessionStorage key "${key}" after clearing old data:`, retryError);
+              try {
+                forceClearAll();
+                window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+                window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
+              } catch (finalError) {
+                authLogger.error(`Failed to set sessionStorage key "${key}" after force clearing:`, finalError);
+                setStoredValue(valueToStore);
+              }
+            }
+          } else {
+            throw storageError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error setting sessionStorage key "${key}":`, error);
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+    }
+  }, "setValue");
+  const removeValue = /* @__PURE__ */ __name(() => {
+    try {
+      setStoredValue(initialValue);
+      if (typeof window !== "undefined") {
+        try {
+          window.sessionStorage.removeItem(key);
+          window.sessionStorage.removeItem(`${key}_timestamp`);
+        } catch (removeError) {
+          if (removeError.name === "QuotaExceededError" || removeError.code === 22 || removeError.message?.includes("quota")) {
+            authLogger.warn("sessionStorage quota exceeded during removal, clearing old data...");
+            clearOldData();
+            try {
+              window.sessionStorage.removeItem(key);
+              window.sessionStorage.removeItem(`${key}_timestamp`);
+            } catch (retryError) {
+              authLogger.error(`Failed to remove sessionStorage key "${key}" after clearing:`, retryError);
+              forceClearAll();
+            }
+          } else {
+            throw removeError;
+          }
+        }
+      }
+    } catch (error) {
+      authLogger.error(`Error removing sessionStorage key "${key}":`, error);
+    }
+  }, "removeValue");
+  return [storedValue, setValue, removeValue];
+}
+__name(useSessionStorage, "useSessionStorage");
+
+// src/auth/hooks/useAuthRedirect.ts
+var AUTH_REDIRECT_KEY = "auth_redirect_url";
+var useAuthRedirectManager = /* @__PURE__ */ __name((options = {}) => {
+  const { fallbackUrl = "/dashboard", clearOnUse = true } = options;
+  const [redirectUrl, setRedirectUrl, removeRedirectUrl] = useSessionStorage(AUTH_REDIRECT_KEY, "");
+  const setRedirect = /* @__PURE__ */ __name((url) => {
+    setRedirectUrl(url);
+  }, "setRedirect");
+  const getRedirect = /* @__PURE__ */ __name(() => {
+    return redirectUrl;
+  }, "getRedirect");
+  const clearRedirect = /* @__PURE__ */ __name(() => {
+    removeRedirectUrl();
+  }, "clearRedirect");
+  const hasRedirect = /* @__PURE__ */ __name(() => {
+    return redirectUrl.length > 0;
+  }, "hasRedirect");
+  const getFinalRedirectUrl = /* @__PURE__ */ __name(() => {
+    return redirectUrl || fallbackUrl;
+  }, "getFinalRedirectUrl");
+  const useAndClearRedirect = /* @__PURE__ */ __name(() => {
+    const finalUrl = getFinalRedirectUrl();
+    if (clearOnUse) {
+      clearRedirect();
+    }
+    return finalUrl;
+  }, "useAndClearRedirect");
+  return {
+    redirectUrl,
+    setRedirect,
+    getRedirect,
+    clearRedirect,
+    hasRedirect,
+    getFinalRedirectUrl,
+    useAndClearRedirect
+  };
+}, "useAuthRedirectManager");
+
 // src/auth/utils/analytics.ts
 var AnalyticsEvent = /* @__PURE__ */ ((AnalyticsEvent2) => {
   AnalyticsEvent2["AUTH_OTP_REQUEST"] = "auth_otp_request";
@@ -3754,7 +3933,7 @@ var Analytics = {
 };
 
 // src/auth/context/AccountsContext.tsx
-var import_react = require("react");
+var import_react2 = require("react");
 
 // src/generated/cfg_accounts/_utils/hooks/accounts__auth.ts
 var import_swr = require("swr");
@@ -3826,20 +4005,20 @@ __name(useCreateAccountsOtpVerifyCreate, "useCreateAccountsOtpVerifyCreate");
 
 // src/auth/context/AccountsContext.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var AccountsContext = (0, import_react.createContext)(void 0);
+var AccountsContext = (0, import_react2.createContext)(void 0);
 function AccountsProvider({ children }) {
-  const [profile, setProfile] = (0, import_react.useState)(() => {
+  const [profile, setProfile] = (0, import_react2.useState)(() => {
     const cached = getCachedProfile();
     return cached || void 0;
   });
-  const [isLoadingProfile, setIsLoadingProfile] = (0, import_react.useState)(false);
-  const [profileError, setProfileError] = (0, import_react.useState)(null);
-  const profileRef = (0, import_react.useRef)(profile);
-  const isLoadingRef = (0, import_react.useRef)(false);
-  (0, import_react.useEffect)(() => {
+  const [isLoadingProfile, setIsLoadingProfile] = (0, import_react2.useState)(false);
+  const [profileError, setProfileError] = (0, import_react2.useState)(null);
+  const profileRef = (0, import_react2.useRef)(profile);
+  const isLoadingRef = (0, import_react2.useRef)(false);
+  (0, import_react2.useEffect)(() => {
     profileRef.current = profile;
   }, [profile]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     isLoadingRef.current = isLoadingProfile;
   }, [isLoadingProfile]);
   const updateMutation = useUpdateAccountsProfileUpdateUpdate();
@@ -3848,7 +4027,7 @@ function AccountsProvider({ children }) {
   const otpRequestMutation = useCreateAccountsOtpRequestCreate();
   const otpVerifyMutation = useCreateAccountsOtpVerifyCreate();
   const tokenRefreshMutation = useCreateAccountsTokenRefreshCreate();
-  const refreshProfile = (0, import_react.useCallback)(async (callerId) => {
+  const refreshProfile = (0, import_react2.useCallback)(async (callerId) => {
     const currentProfile = profileRef.current;
     const currentLoading = isLoadingRef.current;
     if (currentProfile && !currentLoading) {
@@ -3910,7 +4089,7 @@ function AccountsProvider({ children }) {
     }
     return result;
   }, "refreshToken");
-  const logout = (0, import_react.useCallback)(() => {
+  const logout = (0, import_react2.useCallback)(() => {
     api.clearTokens();
     setProfile(void 0);
     setProfileError(null);
@@ -3933,7 +4112,7 @@ function AccountsProvider({ children }) {
 }
 __name(AccountsProvider, "AccountsProvider");
 function useAccountsContext() {
-  const context = (0, import_react.useContext)(AccountsContext);
+  const context = (0, import_react2.useContext)(AccountsContext);
   if (!context) {
     throw new Error("useAccountsContext must be used within AccountsProvider");
   }
@@ -3948,7 +4127,7 @@ var defaultRoutes = {
   defaultCallback: "/dashboard",
   defaultAuthCallback: "/auth"
 };
-var AuthContext = (0, import_react2.createContext)(void 0);
+var AuthContext = (0, import_react3.createContext)(void 0);
 var EMAIL_STORAGE_KEY = "auth_email";
 var PHONE_STORAGE_KEY = "auth_phone";
 var hasValidTokens = /* @__PURE__ */ __name(() => {
@@ -3957,37 +4136,41 @@ var hasValidTokens = /* @__PURE__ */ __name(() => {
 }, "hasValidTokens");
 var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
   const accounts = useAccountsContext();
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(() => {
+  const redirectManager = useAuthRedirectManager({
+    fallbackUrl: config?.routes?.defaultCallback || defaultRoutes.defaultCallback,
+    clearOnUse: true
+  });
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(() => {
     if (typeof window !== "undefined") {
       const hasTokens = hasValidTokens();
       return !hasTokens;
     }
     return true;
   });
-  const [initialized, setInitialized] = (0, import_react2.useState)(false);
+  const [initialized, setInitialized] = (0, import_react3.useState)(false);
   const router = (0, import_hooks2.useCfgRouter)();
   const pathname = (0, import_navigation.usePathname)();
   const queryParams = (0, import_hooks2.useQueryParams)();
   const [storedEmail, setStoredEmail, clearStoredEmail] = (0, import_hooks2.useLocalStorage)(EMAIL_STORAGE_KEY, null);
   const [storedPhone, setStoredPhone, clearStoredPhone] = (0, import_hooks2.useLocalStorage)(PHONE_STORAGE_KEY, null);
   const user = accounts.profile;
-  const userRef = (0, import_react2.useRef)(user);
-  const configRef = (0, import_react2.useRef)(config);
-  const isLoadingProfileRef = (0, import_react2.useRef)(false);
-  (0, import_react2.useEffect)(() => {
+  const userRef = (0, import_react3.useRef)(user);
+  const configRef = (0, import_react3.useRef)(config);
+  const isLoadingProfileRef = (0, import_react3.useRef)(false);
+  (0, import_react3.useEffect)(() => {
     userRef.current = user;
   }, [user]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     configRef.current = config;
   }, [config]);
-  const clearAuthState = (0, import_react2.useCallback)((caller) => {
+  const clearAuthState = (0, import_react3.useCallback)((caller) => {
     authLogger.info("clearAuthState >> caller", caller);
     api.clearTokens();
     clearProfileCache();
     setInitialized(true);
     setIsLoading(false);
   }, []);
-  const handleGlobalAuthError = (0, import_react2.useCallback)((error, context = "API Request") => {
+  const handleGlobalAuthError = (0, import_react3.useCallback)((error, context = "API Request") => {
     if (error?.success === false) {
       authLogger.warn(`Error detected in ${context}, clearing tokens`);
       clearAuthState(`globalAuthError:${context}`);
@@ -3995,7 +4178,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
     }
     return false;
   }, [clearAuthState]);
-  const loadCurrentProfile = (0, import_react2.useCallback)(async (callerId) => {
+  const loadCurrentProfile = (0, import_react3.useCallback)(async (callerId) => {
     const finalCallerId = callerId || "AuthContext.loadCurrentProfile";
     if (isLoadingProfileRef.current) {
       authLogger.debug(`Profile loading already in progress, skipping duplicate call from: ${finalCallerId}`);
@@ -4031,7 +4214,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       isLoadingProfileRef.current = false;
     }
   }, [clearAuthState, handleGlobalAuthError, accounts]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (initialized) return;
     const initializeAuth = /* @__PURE__ */ __name(async () => {
       authLogger.info("Initializing auth...");
@@ -4081,7 +4264,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
     }, "initializeAuth");
     initializeAuth();
   }, [initialized]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!initialized) return;
     const isAuthenticated = api.isAuthenticated();
     const authRoute = config?.routes?.auth || defaultRoutes.auth;
@@ -4092,15 +4275,15 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       router.push(callbackUrl);
     }
   }, [initialized, pathname, queryParams, config?.routes]);
-  const pushToDefaultCallbackUrl = (0, import_react2.useCallback)(() => {
+  const pushToDefaultCallbackUrl = (0, import_react3.useCallback)(() => {
     const callbackUrl = config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
     router.push(callbackUrl);
   }, [config?.routes, router]);
-  const pushToDefaultAuthCallbackUrl = (0, import_react2.useCallback)(() => {
+  const pushToDefaultAuthCallbackUrl = (0, import_react3.useCallback)(() => {
     const authCallbackUrl = config?.routes?.defaultAuthCallback || defaultRoutes.defaultAuthCallback;
     router.push(authCallbackUrl);
   }, [config?.routes, router]);
-  const checkAuthAndRedirect = (0, import_react2.useCallback)(async () => {
+  const checkAuthAndRedirect = (0, import_react3.useCallback)(async () => {
     try {
       setIsLoading(true);
       const isAuthenticated = api.isAuthenticated();
@@ -4122,7 +4305,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       setIsLoading(false);
     }
   }, [loadCurrentProfile, clearAuthState, pushToDefaultCallbackUrl, pushToDefaultAuthCallbackUrl, handleGlobalAuthError]);
-  const requestOTP = (0, import_react2.useCallback)(
+  const requestOTP = (0, import_react3.useCallback)(
     async (identifier, channel, sourceUrl) => {
       api.clearTokens();
       try {
@@ -4150,7 +4333,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
     },
     [accounts]
   );
-  const verifyOTP = (0, import_react2.useCallback)(
+  const verifyOTP = (0, import_react3.useCallback)(
     async (identifier, otpCode, channel, sourceUrl, redirectUrl) => {
       try {
         const channelValue = channel === "phone" ? enums_exports.OTPVerifyRequestChannel.PHONE : enums_exports.OTPVerifyRequestChannel.EMAIL;
@@ -4181,7 +4364,9 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
         if (result.user?.id) {
           Analytics.setUser(String(result.user.id));
         }
-        const finalRedirectUrl = redirectUrl || config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
+        const savedRedirect = redirectManager.useAndClearRedirect();
+        const finalRedirectUrl = redirectUrl || savedRedirect || config?.routes?.defaultCallback || defaultRoutes.defaultCallback;
+        authLogger.info("Redirecting after auth to:", finalRedirectUrl);
         router.hardPush(finalRedirectUrl);
         return {
           success: true,
@@ -4202,7 +4387,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
     },
     [setStoredEmail, setStoredPhone, clearStoredEmail, clearStoredPhone, config?.routes?.defaultCallback, accounts, router]
   );
-  const refreshToken = (0, import_react2.useCallback)(async () => {
+  const refreshToken = (0, import_react3.useCallback)(async () => {
     try {
       const refreshTokenValue = api.getRefreshToken();
       if (!refreshTokenValue) {
@@ -4235,7 +4420,7 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       };
     }
   }, [clearAuthState, accounts]);
-  const logout = (0, import_react2.useCallback)(async () => {
+  const logout = (0, import_react3.useCallback)(async () => {
     const performLogout = /* @__PURE__ */ __name(() => {
       Analytics.event("auth_logout" /* AUTH_LOGOUT */, {
         category: "auth" /* AUTH */
@@ -4264,10 +4449,10 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       }
     }
   }, [accounts, config?.routes?.defaultAuthCallback, router]);
-  const isAdminUser = (0, import_react2.useMemo)(() => {
+  const isAdminUser = (0, import_react3.useMemo)(() => {
     return Boolean(user?.is_staff || user?.is_superuser);
   }, [user]);
-  const value = (0, import_react2.useMemo)(
+  const value = (0, import_react3.useMemo)(
     () => ({
       user,
       isLoading,
@@ -4287,7 +4472,12 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       requestOTP,
       verifyOTP,
       refreshToken,
-      logout
+      logout,
+      // Redirect URL methods
+      saveRedirectUrl: redirectManager.setRedirect,
+      getRedirectUrl: redirectManager.getFinalRedirectUrl,
+      clearRedirectUrl: redirectManager.clearRedirect,
+      hasRedirectUrl: redirectManager.hasRedirect
     }),
     [
       user,
@@ -4304,7 +4494,8 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       requestOTP,
       verifyOTP,
       refreshToken,
-      logout
+      logout,
+      redirectManager
     ]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthContext.Provider, { value, children });
@@ -4313,205 +4504,32 @@ var AuthProvider = /* @__PURE__ */ __name(({ children, config }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AccountsProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthProviderInternal, { config, children }) });
 }, "AuthProvider");
 var useAuth = /* @__PURE__ */ __name(() => {
-  const context = (0, import_react2.useContext)(AuthContext);
+  const context = (0, import_react3.useContext)(AuthContext);
   if (context === void 0) {
     throw new Error("useAuth must be used within an AuthProvider");
   }
   return context;
 }, "useAuth");
 
-// src/auth/hooks/useSessionStorage.ts
-var import_react3 = require("react");
-function useSessionStorage(key, initialValue) {
-  const [storedValue, setStoredValue] = (0, import_react3.useState)(() => {
-    if (typeof window === "undefined") {
-      return initialValue;
-    }
-    try {
-      const item = window.sessionStorage.getItem(key);
-      return item ? JSON.parse(item) : initialValue;
-    } catch (error) {
-      authLogger.error(`Error reading sessionStorage key "${key}":`, error);
-      return initialValue;
-    }
-  });
-  const checkDataSize = /* @__PURE__ */ __name((data) => {
-    try {
-      const jsonString = JSON.stringify(data);
-      const sizeInBytes = new Blob([jsonString]).size;
-      const sizeInKB = sizeInBytes / 1024;
-      if (sizeInKB > 1024) {
-        authLogger.warn(`Data size (${sizeInKB.toFixed(2)}KB) exceeds 1MB limit for key "${key}"`);
-        return false;
-      }
-      return true;
-    } catch (error) {
-      authLogger.error(`Error checking data size for key "${key}":`, error);
-      return false;
-    }
-  }, "checkDataSize");
-  const clearOldData = /* @__PURE__ */ __name(() => {
-    try {
-      const keys = Object.keys(sessionStorage).filter((key2) => key2 && typeof key2 === "string");
-      if (keys.length > 50) {
-        const itemsToRemove = Math.ceil(keys.length * 0.2);
-        for (let i = 0; i < itemsToRemove; i++) {
-          try {
-            const key2 = keys[i];
-            if (key2) {
-              sessionStorage.removeItem(key2);
-              sessionStorage.removeItem(`${key2}_timestamp`);
-            }
-          } catch {
-          }
-        }
-      }
-    } catch (error) {
-      authLogger.error("Error clearing old sessionStorage data:", error);
-    }
-  }, "clearOldData");
-  const forceClearAll = /* @__PURE__ */ __name(() => {
-    try {
-      const keys = Object.keys(sessionStorage);
-      for (const key2 of keys) {
-        try {
-          sessionStorage.removeItem(key2);
-        } catch {
-        }
-      }
-    } catch (error) {
-      authLogger.error("Error force clearing sessionStorage:", error);
-    }
-  }, "forceClearAll");
-  const setValue = /* @__PURE__ */ __name((value) => {
-    try {
-      const valueToStore = value instanceof Function ? value(storedValue) : value;
-      if (!checkDataSize(valueToStore)) {
-        authLogger.warn(`Data size too large for key "${key}", removing key`);
-        try {
-          window.sessionStorage.removeItem(key);
-          window.sessionStorage.removeItem(`${key}_timestamp`);
-        } catch {
-        }
-        setStoredValue(valueToStore);
-        return;
-      }
-      setStoredValue(valueToStore);
-      if (typeof window !== "undefined") {
-        try {
-          window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-          window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
-        } catch (storageError) {
-          if (storageError.name === "QuotaExceededError" || storageError.code === 22 || storageError.message?.includes("quota")) {
-            authLogger.warn("sessionStorage quota exceeded, clearing old data...");
-            clearOldData();
-            try {
-              window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-              window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
-            } catch (retryError) {
-              authLogger.error(`Failed to set sessionStorage key "${key}" after clearing old data:`, retryError);
-              try {
-                forceClearAll();
-                window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
-                window.sessionStorage.setItem(`${key}_timestamp`, Date.now().toString());
-              } catch (finalError) {
-                authLogger.error(`Failed to set sessionStorage key "${key}" after force clearing:`, finalError);
-                setStoredValue(valueToStore);
-              }
-            }
-          } else {
-            throw storageError;
-          }
-        }
-      }
-    } catch (error) {
-      authLogger.error(`Error setting sessionStorage key "${key}":`, error);
-      const valueToStore = value instanceof Function ? value(storedValue) : value;
-      setStoredValue(valueToStore);
-    }
-  }, "setValue");
-  const removeValue = /* @__PURE__ */ __name(() => {
-    try {
-      setStoredValue(initialValue);
-      if (typeof window !== "undefined") {
-        try {
-          window.sessionStorage.removeItem(key);
-          window.sessionStorage.removeItem(`${key}_timestamp`);
-        } catch (removeError) {
-          if (removeError.name === "QuotaExceededError" || removeError.code === 22 || removeError.message?.includes("quota")) {
-            authLogger.warn("sessionStorage quota exceeded during removal, clearing old data...");
-            clearOldData();
-            try {
-              window.sessionStorage.removeItem(key);
-              window.sessionStorage.removeItem(`${key}_timestamp`);
-            } catch (retryError) {
-              authLogger.error(`Failed to remove sessionStorage key "${key}" after clearing:`, retryError);
-              forceClearAll();
-            }
-          } else {
-            throw removeError;
-          }
-        }
-      }
-    } catch (error) {
-      authLogger.error(`Error removing sessionStorage key "${key}":`, error);
-    }
-  }, "removeValue");
-  return [storedValue, setValue, removeValue];
-}
-__name(useSessionStorage, "useSessionStorage");
-
-// src/auth/hooks/useAuthRedirect.ts
-var AUTH_REDIRECT_KEY = "auth_redirect_url";
-var useAuthRedirectManager = /* @__PURE__ */ __name((options = {}) => {
-  const { fallbackUrl = "/dashboard", clearOnUse = true } = options;
-  const [redirectUrl, setRedirectUrl, removeRedirectUrl] = useSessionStorage(AUTH_REDIRECT_KEY, "");
-  const setRedirect = /* @__PURE__ */ __name((url) => {
-    setRedirectUrl(url);
-  }, "setRedirect");
-  const getRedirect = /* @__PURE__ */ __name(() => {
-    return redirectUrl;
-  }, "getRedirect");
-  const clearRedirect = /* @__PURE__ */ __name(() => {
-    removeRedirectUrl();
-  }, "clearRedirect");
-  const hasRedirect = /* @__PURE__ */ __name(() => {
-    return redirectUrl.length > 0;
-  }, "hasRedirect");
-  const getFinalRedirectUrl = /* @__PURE__ */ __name(() => {
-    return redirectUrl || fallbackUrl;
-  }, "getFinalRedirectUrl");
-  const useAndClearRedirect = /* @__PURE__ */ __name(() => {
-    const finalUrl = getFinalRedirectUrl();
-    if (clearOnUse) {
-      clearRedirect();
-    }
-    return finalUrl;
-  }, "useAndClearRedirect");
-  return {
-    redirectUrl,
-    setRedirect,
-    getRedirect,
-    clearRedirect,
-    hasRedirect,
-    getFinalRedirectUrl,
-    useAndClearRedirect
-  };
-}, "useAuthRedirectManager");
-
 // src/auth/hooks/useAuthGuard.ts
 var import_react4 = require("react");
 var import_hooks3 = require("@djangocfg/ui-nextjs/hooks");
 var useAuthGuard = /* @__PURE__ */ __name((options = {}) => {
-  const { redirectTo = "/auth", requireAuth = true } = options;
-  const { isAuthenticated, isLoading } = useAuth();
+  const { redirectTo = "/auth", requireAuth = true, saveRedirectUrl: shouldSaveUrl = true } = options;
+  const { isAuthenticated, isLoading, saveRedirectUrl } = useAuth();
   const router = (0, import_hooks3.useCfgRouter)();
+  const [isRedirecting, setIsRedirecting] = (0, import_react4.useState)(false);
   (0, import_react4.useEffect)(() => {
-    if (!isLoading && requireAuth && !isAuthenticated) {
+    if (!isLoading && requireAuth && !isAuthenticated && !isRedirecting) {
+      if (shouldSaveUrl && typeof window !== "undefined") {
+        const currentUrl = window.location.pathname + window.location.search;
+        saveRedirectUrl(currentUrl);
+      }
+      setIsRedirecting(true);
       router.push(redirectTo);
     }
-  }, [isAuthenticated, isLoading, router, redirectTo, requireAuth]);
-  return { isAuthenticated, isLoading };
+  }, [isAuthenticated, isLoading, router, redirectTo, requireAuth, isRedirecting, shouldSaveUrl, saveRedirectUrl]);
+  return { isAuthenticated, isLoading, isRedirecting };
 }, "useAuthGuard");
 
 // src/auth/hooks/useLocalStorage.ts
@@ -4682,34 +4700,37 @@ var import_navigation2 = require("next/navigation");
 var import_react6 = require("react");
 var import_hooks4 = require("@djangocfg/ui-nextjs/hooks");
 var useAutoAuth = /* @__PURE__ */ __name((options = {}) => {
-  const { onOTPDetected, cleanupUrl = true } = options;
+  const { onOTPDetected, cleanupUrl = true, allowedPaths = ["/auth"] } = options;
   const queryParams = (0, import_hooks4.useQueryParams)();
   const pathname = (0, import_navigation2.usePathname)();
   const router = (0, import_hooks4.useCfgRouter)();
-  const isReady = !!pathname && !!queryParams.get("otp");
+  const isAllowedPath = allowedPaths.some((path) => pathname === path || pathname?.startsWith(path + "/"));
   const hasOTP = !!queryParams.get("otp");
+  const isReady = !!pathname && hasOTP && isAllowedPath;
   (0, import_react6.useEffect)(() => {
     if (!isReady) return;
     const queryOtp = queryParams.get("otp");
     if (queryOtp && typeof queryOtp === "string" && queryOtp.length === 6) {
-      authLogger.info("OTP detected in URL:", queryOtp);
+      authLogger.info("OTP detected in URL on auth page:", queryOtp);
       onOTPDetected?.(queryOtp);
     }
     if (cleanupUrl && queryOtp) {
       const cleanQuery = Object.fromEntries(queryParams.entries());
       delete cleanQuery.otp;
-      router.push(`${pathname}?${new URLSearchParams(cleanQuery).toString()}`);
+      const queryString = new URLSearchParams(cleanQuery).toString();
+      router.push(queryString ? `${pathname}?${queryString}` : pathname);
     }
-  }, [pathname, queryParams, onOTPDetected, cleanupUrl, router]);
+  }, [pathname, queryParams, onOTPDetected, cleanupUrl, router, isReady]);
   return {
     isReady,
-    hasOTP
+    hasOTP,
+    isAllowedPath
   };
 }, "useAutoAuth");
 
 // src/auth/hooks/useAuthForm.ts
 var useAuthForm = /* @__PURE__ */ __name((options) => {
-  const { onIdentifierSuccess, onOTPSuccess, onError, sourceUrl, redirectUrl, requireTermsAcceptance = false } = options;
+  const { onIdentifierSuccess, onOTPSuccess, onError, sourceUrl, redirectUrl, requireTermsAcceptance = false, authPath = "/auth" } = options;
   const [identifier, setIdentifier] = (0, import_react7.useState)("");
   const [channel, setChannel] = (0, import_react7.useState)("email");
   const [otp, setOtp] = (0, import_react7.useState)("");
@@ -4883,6 +4904,7 @@ var useAuthForm = /* @__PURE__ */ __name((options) => {
     setSavedTermsAccepted(checked);
   }, [setSavedTermsAccepted]);
   useAutoAuth({
+    allowedPaths: [authPath],
     onOTPDetected: /* @__PURE__ */ __name((otp2) => {
       authLogger.info("OTP detected, auto-submitting");
       const savedEmail2 = getSavedEmail();