@pixygon/auth 1.0.0

package/dist/chunk-E34M2RJD.mjs

@@ -0,0 +1,1003 @@
+// src/utils/storage.ts
+var getKeys = (appId) => ({
+  ACCESS_TOKEN: `${appId}_access_token`,
+  REFRESH_TOKEN: `${appId}_refresh_token`,
+  USER: `${appId}_user`,
+  EXPIRES_AT: `${appId}_expires_at`
+});
+var defaultStorage = {
+  getItem: (key) => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(key);
+  },
+  setItem: (key, value) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(key, value);
+  },
+  removeItem: (key) => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(key);
+  }
+};
+function createTokenStorage(appId, storage = defaultStorage) {
+  const keys = getKeys(appId);
+  return {
+    /**
+     * Get the stored access token
+     */
+    getAccessToken: async () => {
+      const token = await storage.getItem(keys.ACCESS_TOKEN);
+      return token;
+    },
+    /**
+     * Get the stored refresh token
+     */
+    getRefreshToken: async () => {
+      const token = await storage.getItem(keys.REFRESH_TOKEN);
+      return token;
+    },
+    /**
+     * Get the stored user
+     */
+    getUser: async () => {
+      const userJson = await storage.getItem(keys.USER);
+      if (!userJson) return null;
+      try {
+        return JSON.parse(userJson);
+      } catch {
+        return null;
+      }
+    },
+    /**
+     * Get token expiration time
+     */
+    getExpiresAt: async () => {
+      const expiresAt = await storage.getItem(keys.EXPIRES_AT);
+      return expiresAt ? parseInt(expiresAt, 10) : null;
+    },
+    /**
+     * Check if access token is expired
+     */
+    isTokenExpired: async () => {
+      const expiresAt = await storage.getItem(keys.EXPIRES_AT);
+      if (!expiresAt) return true;
+      return Date.now() >= parseInt(expiresAt, 10);
+    },
+    /**
+     * Check if token will expire within threshold (in seconds)
+     */
+    willExpireSoon: async (thresholdSeconds = 300) => {
+      const expiresAt = await storage.getItem(keys.EXPIRES_AT);
+      if (!expiresAt) return true;
+      const expiryTime = parseInt(expiresAt, 10);
+      const thresholdMs = thresholdSeconds * 1e3;
+      return Date.now() >= expiryTime - thresholdMs;
+    },
+    /**
+     * Store tokens and user data
+     */
+    setTokens: async (accessToken, refreshToken, expiresIn, user) => {
+      await storage.setItem(keys.ACCESS_TOKEN, accessToken);
+      if (refreshToken) {
+        await storage.setItem(keys.REFRESH_TOKEN, refreshToken);
+      }
+      if (expiresIn) {
+        const expiresAt = Date.now() + expiresIn * 1e3;
+        await storage.setItem(keys.EXPIRES_AT, expiresAt.toString());
+      }
+      await storage.setItem(keys.USER, JSON.stringify(user));
+    },
+    /**
+     * Update tokens after refresh
+     */
+    updateTokens: async (tokens) => {
+      await storage.setItem(keys.ACCESS_TOKEN, tokens.accessToken);
+      await storage.setItem(keys.REFRESH_TOKEN, tokens.refreshToken);
+      const expiresAt = Date.now() + tokens.expiresIn * 1e3;
+      await storage.setItem(keys.EXPIRES_AT, expiresAt.toString());
+    },
+    /**
+     * Update user data
+     */
+    updateUser: async (user) => {
+      await storage.setItem(keys.USER, JSON.stringify(user));
+    },
+    /**
+     * Clear all stored auth data
+     */
+    clear: async () => {
+      await storage.removeItem(keys.ACCESS_TOKEN);
+      await storage.removeItem(keys.REFRESH_TOKEN);
+      await storage.removeItem(keys.USER);
+      await storage.removeItem(keys.EXPIRES_AT);
+    },
+    /**
+     * Get all stored auth data
+     */
+    getAll: async () => {
+      const [accessToken, refreshToken, user, expiresAt] = await Promise.all([
+        storage.getItem(keys.ACCESS_TOKEN),
+        storage.getItem(keys.REFRESH_TOKEN),
+        storage.getItem(keys.USER),
+        storage.getItem(keys.EXPIRES_AT)
+      ]);
+      return {
+        accessToken,
+        refreshToken,
+        user: user ? JSON.parse(user) : null,
+        expiresAt: expiresAt ? parseInt(expiresAt, 10) : null
+      };
+    }
+  };
+}
+
+// src/api/client.ts
+function parseErrorCode(status, message) {
+  if (message?.toLowerCase().includes("not found")) return "USER_NOT_FOUND";
+  if (message?.toLowerCase().includes("exists")) return "USER_EXISTS";
+  if (message?.toLowerCase().includes("verified")) return "EMAIL_NOT_VERIFIED";
+  if (message?.toLowerCase().includes("invalid") && message?.toLowerCase().includes("code")) {
+    return "INVALID_VERIFICATION_CODE";
+  }
+  if (message?.toLowerCase().includes("expired") && message?.toLowerCase().includes("code")) {
+    return "EXPIRED_VERIFICATION_CODE";
+  }
+  switch (status) {
+    case 401:
+      return "INVALID_CREDENTIALS";
+    case 403:
+      return "TOKEN_INVALID";
+    case 404:
+      return "USER_NOT_FOUND";
+    case 409:
+      return "USER_EXISTS";
+    case 500:
+      return "SERVER_ERROR";
+    default:
+      return "UNKNOWN_ERROR";
+  }
+}
+function createAuthError(status, message, details) {
+  return {
+    code: parseErrorCode(status, message),
+    message: message || "An unexpected error occurred",
+    details
+  };
+}
+function createAuthApiClient(config, tokenStorage) {
+  let currentAccessToken = null;
+  let isRefreshing = false;
+  let refreshPromise = null;
+  const log = (...args) => {
+    if (config.debug) {
+      console.log("[PixygonAuth]", ...args);
+    }
+  };
+  async function request(endpoint, options = {}) {
+    const url = `${config.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (currentAccessToken) {
+      headers["Authorization"] = `Bearer ${currentAccessToken}`;
+    }
+    log(`Request: ${options.method || "GET"} ${endpoint}`);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers
+      });
+      if (response.status === 401 || response.status === 403) {
+        if (currentAccessToken && !isRefreshing) {
+          log("Token expired, attempting refresh...");
+          try {
+            await refreshTokens();
+            headers["Authorization"] = `Bearer ${currentAccessToken}`;
+            const retryResponse = await fetch(url, { ...options, headers });
+            if (!retryResponse.ok) {
+              const errorData = await retryResponse.json().catch(() => ({}));
+              throw createAuthError(retryResponse.status, errorData.message);
+            }
+            return retryResponse.json();
+          } catch (refreshError) {
+            log("Token refresh failed", refreshError);
+            throw createAuthError(401, "Session expired. Please log in again.");
+          }
+        }
+        throw createAuthError(response.status, "Authentication required");
+      }
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw createAuthError(response.status, errorData.message, errorData);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error.code) {
+        throw error;
+      }
+      log("Network error:", error);
+      throw {
+        code: "NETWORK_ERROR",
+        message: "Unable to connect to the server",
+        details: { originalError: error }
+      };
+    }
+  }
+  async function refreshTokens() {
+    if (isRefreshing && refreshPromise) {
+      return refreshPromise;
+    }
+    isRefreshing = true;
+    refreshPromise = (async () => {
+      try {
+        const refreshToken = await tokenStorage.getRefreshToken();
+        if (!refreshToken) {
+          throw new Error("No refresh token available");
+        }
+        const response = await fetch(`${config.baseUrl}/auth/refresh`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ refreshToken })
+        });
+        if (!response.ok) {
+          throw new Error("Refresh failed");
+        }
+        const data = await response.json();
+        currentAccessToken = data.token;
+        await tokenStorage.updateTokens({
+          accessToken: data.token,
+          refreshToken: data.refreshToken,
+          expiresIn: data.expiresIn,
+          refreshExpiresIn: data.expiresIn * 24
+          // Approximate
+        });
+        config.onTokenRefresh?.({
+          accessToken: data.token,
+          refreshToken: data.refreshToken,
+          expiresIn: data.expiresIn,
+          refreshExpiresIn: data.expiresIn * 24
+        });
+        log("Token refreshed successfully");
+      } finally {
+        isRefreshing = false;
+        refreshPromise = null;
+      }
+    })();
+    return refreshPromise;
+  }
+  return {
+    // ========================================================================
+    // Auth Endpoints
+    // ========================================================================
+    async login(data) {
+      const response = await request("/auth/login", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      currentAccessToken = response.token;
+      await tokenStorage.setTokens(
+        response.token,
+        response.refreshToken || null,
+        response.expiresIn || null,
+        response.user
+      );
+      config.onLogin?.(response.user);
+      log("Login successful:", response.user.userName);
+      return response;
+    },
+    async register(data) {
+      const response = await request("/auth/register", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      log("Registration successful:", response.user.userName);
+      return response;
+    },
+    async verify(data) {
+      const response = await request("/auth/verify", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      currentAccessToken = response.token;
+      await tokenStorage.setTokens(
+        response.token,
+        response.refreshToken || null,
+        null,
+        response.user
+      );
+      config.onLogin?.(response.user);
+      log("Verification successful:", response.user.userName);
+      return response;
+    },
+    async resendVerification(data) {
+      const response = await request("/auth/resendVerificationEmail", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      log("Verification email resent");
+      return response;
+    },
+    async forgotPassword(data) {
+      const response = await request("/auth/forgotPassword", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      log("Password reset email sent");
+      return response;
+    },
+    async recoverPassword(data) {
+      const response = await request("/auth/recoverPassword", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      log("Password recovered successfully");
+      return response;
+    },
+    async refreshToken(data) {
+      const response = await request("/auth/refresh", {
+        method: "POST",
+        body: JSON.stringify(data)
+      });
+      currentAccessToken = response.token;
+      await tokenStorage.updateTokens({
+        accessToken: response.token,
+        refreshToken: response.refreshToken,
+        expiresIn: response.expiresIn,
+        refreshExpiresIn: response.expiresIn * 24
+      });
+      return response;
+    },
+    // ========================================================================
+    // User Endpoints
+    // ========================================================================
+    async getMe() {
+      const response = await request("/users/me");
+      await tokenStorage.updateUser(response);
+      return response;
+    },
+    async updateProfile(data) {
+      const response = await request("/users/me", {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      });
+      await tokenStorage.updateUser(response);
+      return response;
+    },
+    // ========================================================================
+    // Utilities
+    // ========================================================================
+    setAccessToken(token) {
+      currentAccessToken = token;
+    },
+    getAccessToken() {
+      return currentAccessToken;
+    },
+    request
+  };
+}
+
+// src/providers/AuthProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback,
+  useMemo
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+var defaultConfig = {
+  autoRefresh: true,
+  refreshThreshold: 300,
+  // 5 minutes before expiry
+  debug: false
+};
+function AuthProvider({ config: userConfig, children }) {
+  const config = useMemo(() => ({ ...defaultConfig, ...userConfig }), [userConfig]);
+  const tokenStorage = useMemo(
+    () => createTokenStorage(config.appId, config.storage),
+    [config.appId, config.storage]
+  );
+  const apiClient = useMemo(
+    () => createAuthApiClient(config, tokenStorage),
+    [config, tokenStorage]
+  );
+  const [state, setState] = useState({
+    user: null,
+    accessToken: null,
+    refreshToken: null,
+    status: "idle",
+    isLoading: true,
+    error: null
+  });
+  const log = useCallback(
+    (...args) => {
+      if (config.debug) {
+        console.log("[PixygonAuth]", ...args);
+      }
+    },
+    [config.debug]
+  );
+  useEffect(() => {
+    let mounted = true;
+    async function initializeAuth() {
+      log("Initializing auth...");
+      try {
+        const stored = await tokenStorage.getAll();
+        if (!stored.accessToken || !stored.user) {
+          log("No stored auth found");
+          if (mounted) {
+            setState((prev) => ({
+              ...prev,
+              status: "unauthenticated",
+              isLoading: false
+            }));
+          }
+          return;
+        }
+        const isExpired = await tokenStorage.isTokenExpired();
+        if (isExpired && stored.refreshToken) {
+          log("Token expired, attempting refresh...");
+          try {
+            const response = await apiClient.refreshToken({
+              refreshToken: stored.refreshToken
+            });
+            if (mounted) {
+              setState({
+                user: stored.user,
+                accessToken: response.token,
+                refreshToken: response.refreshToken,
+                status: "authenticated",
+                isLoading: false,
+                error: null
+              });
+              apiClient.setAccessToken(response.token);
+            }
+          } catch (error) {
+            log("Token refresh failed:", error);
+            await tokenStorage.clear();
+            if (mounted) {
+              setState({
+                user: null,
+                accessToken: null,
+                refreshToken: null,
+                status: "unauthenticated",
+                isLoading: false,
+                error: null
+              });
+            }
+          }
+        } else if (!isExpired) {
+          log("Restoring auth from storage");
+          apiClient.setAccessToken(stored.accessToken);
+          if (mounted) {
+            setState({
+              user: stored.user,
+              accessToken: stored.accessToken,
+              refreshToken: stored.refreshToken,
+              status: stored.user.isVerified ? "authenticated" : "verifying",
+              isLoading: false,
+              error: null
+            });
+          }
+        } else {
+          log("Token expired and no refresh token available");
+          await tokenStorage.clear();
+          if (mounted) {
+            setState({
+              user: null,
+              accessToken: null,
+              refreshToken: null,
+              status: "unauthenticated",
+              isLoading: false,
+              error: null
+            });
+          }
+        }
+      } catch (error) {
+        log("Auth initialization error:", error);
+        if (mounted) {
+          setState((prev) => ({
+            ...prev,
+            status: "unauthenticated",
+            isLoading: false,
+            error: {
+              code: "UNKNOWN_ERROR",
+              message: "Failed to initialize authentication"
+            }
+          }));
+        }
+      }
+    }
+    initializeAuth();
+    return () => {
+      mounted = false;
+    };
+  }, [apiClient, tokenStorage, log]);
+  useEffect(() => {
+    if (!config.autoRefresh || state.status !== "authenticated") {
+      return;
+    }
+    const checkAndRefresh = async () => {
+      const willExpire = await tokenStorage.willExpireSoon(config.refreshThreshold || 300);
+      if (willExpire && state.refreshToken) {
+        log("Token expiring soon, refreshing...");
+        try {
+          const response = await apiClient.refreshToken({
+            refreshToken: state.refreshToken
+          });
+          setState((prev) => ({
+            ...prev,
+            accessToken: response.token,
+            refreshToken: response.refreshToken
+          }));
+          apiClient.setAccessToken(response.token);
+        } catch (error) {
+          log("Auto-refresh failed:", error);
+        }
+      }
+    };
+    const interval = setInterval(checkAndRefresh, 6e4);
+    return () => clearInterval(interval);
+  }, [
+    config.autoRefresh,
+    config.refreshThreshold,
+    state.status,
+    state.refreshToken,
+    apiClient,
+    tokenStorage,
+    log
+  ]);
+  const login = useCallback(
+    async (credentials) => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      try {
+        const response = await apiClient.login(credentials);
+        const newStatus = response.user.isVerified ? "authenticated" : "verifying";
+        setState({
+          user: response.user,
+          accessToken: response.token,
+          refreshToken: response.refreshToken || null,
+          status: newStatus,
+          isLoading: false,
+          error: null
+        });
+        return response;
+      } catch (error) {
+        const authError = error;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+  const register = useCallback(
+    async (data) => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      try {
+        const response = await apiClient.register(data);
+        setState((prev) => ({
+          ...prev,
+          isLoading: false
+        }));
+        return response;
+      } catch (error) {
+        const authError = error;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+  const verify = useCallback(
+    async (data) => {
+      setState((prev) => ({ ...prev, isLoading: true, error: null }));
+      try {
+        const response = await apiClient.verify(data);
+        setState({
+          user: response.user,
+          accessToken: response.token,
+          refreshToken: response.refreshToken || null,
+          status: "authenticated",
+          isLoading: false,
+          error: null
+        });
+        return response;
+      } catch (error) {
+        const authError = error;
+        setState((prev) => ({
+          ...prev,
+          isLoading: false,
+          error: authError
+        }));
+        config.onError?.(authError);
+        throw error;
+      }
+    },
+    [apiClient, config]
+  );
+  const resendVerification = useCallback(
+    async (data) => {
+      return apiClient.resendVerification(data);
+    },
+    [apiClient]
+  );
+  const forgotPassword = useCallback(
+    async (data) => {
+      return apiClient.forgotPassword(data);
+    },
+    [apiClient]
+  );
+  const recoverPassword = useCallback(
+    async (data) => {
+      return apiClient.recoverPassword(data);
+    },
+    [apiClient]
+  );
+  const logout = useCallback(async () => {
+    log("Logging out...");
+    await tokenStorage.clear();
+    apiClient.setAccessToken(null);
+    setState({
+      user: null,
+      accessToken: null,
+      refreshToken: null,
+      status: "unauthenticated",
+      isLoading: false,
+      error: null
+    });
+    config.onLogout?.();
+  }, [tokenStorage, apiClient, config, log]);
+  const refreshTokens = useCallback(async () => {
+    if (!state.refreshToken) {
+      throw new Error("No refresh token available");
+    }
+    const response = await apiClient.refreshToken({
+      refreshToken: state.refreshToken
+    });
+    setState((prev) => ({
+      ...prev,
+      accessToken: response.token,
+      refreshToken: response.refreshToken
+    }));
+  }, [apiClient, state.refreshToken]);
+  const getAccessToken = useCallback(() => state.accessToken, [state.accessToken]);
+  const hasRole = useCallback(
+    (role) => {
+      if (!state.user) return false;
+      const roles = Array.isArray(role) ? role : [role];
+      return roles.includes(state.user.role);
+    },
+    [state.user]
+  );
+  const contextValue = useMemo(
+    () => ({
+      // State
+      ...state,
+      isAuthenticated: state.status === "authenticated",
+      isVerified: state.user?.isVerified ?? false,
+      // Actions
+      login,
+      register,
+      logout,
+      verify,
+      resendVerification,
+      forgotPassword,
+      recoverPassword,
+      refreshTokens,
+      // Utilities
+      getAccessToken,
+      hasRole,
+      // Config
+      config
+    }),
+    [
+      state,
+      login,
+      register,
+      logout,
+      verify,
+      resendVerification,
+      forgotPassword,
+      recoverPassword,
+      refreshTokens,
+      getAccessToken,
+      hasRole,
+      config
+    ]
+  );
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
+}
+function useAuthContext() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuthContext must be used within an AuthProvider");
+  }
+  return context;
+}
+
+// src/hooks/useProfileSync.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+function useProfileSync() {
+  const { user, config, getAccessToken } = useAuthContext();
+  const [profile, setProfile] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [isSyncing, setIsSyncing] = useState2(false);
+  const [error, setError] = useState2(null);
+  const fetchProfile = useCallback2(async () => {
+    const token = getAccessToken();
+    if (!token || !user) {
+      setProfile(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      const response = await fetch(`${config.baseUrl}/users/profile`, {
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "X-App-Id": config.appId
+        }
+      });
+      if (!response.ok) {
+        throw new Error("Failed to fetch profile");
+      }
+      const data = await response.json();
+      setProfile({
+        ...user,
+        ...data.user,
+        lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch profile"));
+      setProfile(user ? { ...user, lastSyncedAt: void 0 } : null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, user]);
+  useEffect2(() => {
+    if (user) {
+      fetchProfile();
+    } else {
+      setProfile(null);
+      setIsLoading(false);
+    }
+  }, [user, fetchProfile]);
+  const syncProfile = useCallback2(async () => {
+    if (!user) return;
+    setIsSyncing(true);
+    await fetchProfile();
+    setIsSyncing(false);
+  }, [user, fetchProfile]);
+  const updateProfile = useCallback2(async (updates) => {
+    const token = getAccessToken();
+    if (!token || !profile) {
+      throw new Error("Not authenticated");
+    }
+    setIsSyncing(true);
+    try {
+      const response = await fetch(`${config.baseUrl}/users/profile`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "X-App-Id": config.appId
+        },
+        body: JSON.stringify(updates)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || "Failed to update profile");
+      }
+      const data = await response.json();
+      setProfile({
+        ...profile,
+        ...data.user,
+        lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      setError(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update profile");
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsSyncing(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, profile]);
+  const updatePreferences = useCallback2(async (preferences) => {
+    await updateProfile({
+      preferences: {
+        ...profile?.preferences,
+        ...preferences
+      }
+    });
+  }, [updateProfile, profile?.preferences]);
+  const linkApp = useCallback2(async (appId) => {
+    const token = getAccessToken();
+    if (!token) {
+      throw new Error("Not authenticated");
+    }
+    setIsSyncing(true);
+    try {
+      const response = await fetch(`${config.baseUrl}/users/link-app`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "X-App-Id": config.appId
+        },
+        body: JSON.stringify({ appId })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.message || "Failed to link app");
+      }
+      await fetchProfile();
+      setError(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to link app");
+      setError(error2);
+      throw error2;
+    } finally {
+      setIsSyncing(false);
+    }
+  }, [config.baseUrl, config.appId, getAccessToken, fetchProfile]);
+  return {
+    profile,
+    isLoading,
+    isSyncing,
+    error,
+    updateProfile,
+    syncProfile,
+    updatePreferences,
+    linkApp
+  };
+}
+
+// src/hooks/index.ts
+import { useMemo as useMemo2, useEffect as useEffect3 } from "react";
+function useAuth() {
+  const context = useAuthContext();
+  return useMemo2(
+    () => ({
+      // State
+      user: context.user,
+      status: context.status,
+      isLoading: context.isLoading,
+      isAuthenticated: context.isAuthenticated,
+      isVerified: context.isVerified,
+      error: context.error,
+      // Actions
+      login: context.login,
+      register: context.register,
+      logout: context.logout,
+      verify: context.verify,
+      resendVerification: context.resendVerification,
+      forgotPassword: context.forgotPassword,
+      recoverPassword: context.recoverPassword,
+      // Utilities
+      hasRole: context.hasRole
+    }),
+    [context]
+  );
+}
+function useUser() {
+  const { user, isAuthenticated, isVerified, hasRole } = useAuthContext();
+  return useMemo2(() => {
+    const dailyTokens = user?.dailyTokens ?? 0;
+    const purchasedTokens = user?.purchasedTokens ?? 0;
+    const bonusTokens = user?.bonusTokens ?? 0;
+    const subscriptionTokens = user?.subscriptionTokens ?? 0;
+    return {
+      user,
+      isAuthenticated,
+      isVerified,
+      role: user?.role ?? null,
+      hasRole,
+      // Shortcuts
+      userId: user?._id ?? null,
+      userName: user?.userName ?? null,
+      email: user?.email ?? null,
+      profilePicture: user?.profilePicture ?? null,
+      subscriptionTier: user?.subscriptionTier ?? null,
+      // Tokens
+      dailyTokens,
+      purchasedTokens,
+      bonusTokens,
+      subscriptionTokens,
+      totalTokens: dailyTokens + purchasedTokens + bonusTokens + subscriptionTokens
+    };
+  }, [user, isAuthenticated, isVerified, hasRole]);
+}
+function useToken() {
+  const { accessToken, refreshToken, getAccessToken, refreshTokens, isAuthenticated } = useAuthContext();
+  return useMemo2(
+    () => ({
+      accessToken,
+      refreshToken,
+      getAccessToken,
+      refreshTokens,
+      isAuthenticated
+    }),
+    [accessToken, refreshToken, getAccessToken, refreshTokens, isAuthenticated]
+  );
+}
+function useAuthStatus() {
+  const { status, isLoading } = useAuthContext();
+  return useMemo2(
+    () => ({
+      status,
+      isIdle: status === "idle",
+      isLoading,
+      isAuthenticated: status === "authenticated",
+      isUnauthenticated: status === "unauthenticated",
+      isVerifying: status === "verifying"
+    }),
+    [status, isLoading]
+  );
+}
+function useRequireAuth(options = {}) {
+  const { roles, onUnauthorized } = options;
+  const { user, isAuthenticated, isLoading, hasRole } = useAuthContext();
+  const isAuthorized = useMemo2(() => {
+    if (!isAuthenticated) return false;
+    if (roles && roles.length > 0 && !hasRole(roles)) return false;
+    return true;
+  }, [isAuthenticated, roles, hasRole]);
+  useEffect3(() => {
+    if (!isLoading && !isAuthorized && onUnauthorized) {
+      onUnauthorized();
+    }
+  }, [isLoading, isAuthorized, onUnauthorized]);
+  return useMemo2(
+    () => ({
+      isAuthorized,
+      isLoading,
+      user
+    }),
+    [isAuthorized, isLoading, user]
+  );
+}
+function useAuthError() {
+  const context = useAuthContext();
+  return useMemo2(
+    () => ({
+      error: context.error,
+      hasError: !!context.error,
+      errorMessage: context.error?.message ?? null,
+      errorCode: context.error?.code ?? null,
+      clearError: () => {
+      }
+    }),
+    [context.error]
+  );
+}
+
+export {
+  createTokenStorage,
+  createAuthApiClient,
+  AuthContext,
+  AuthProvider,
+  useAuthContext,
+  useProfileSync,
+  useAuth,
+  useUser,
+  useToken,
+  useAuthStatus,
+  useRequireAuth,
+  useAuthError
+};