@pixygon/auth 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,233 @@
+import { A as AuthContextValue, a as AuthConfig, U as User, b as AuthError, c as AuthStatus, d as UserRole, e as AuthStorage, T as TokenPair, L as LoginRequest, f as LoginResponse, R as RegisterRequest, g as RegisterResponse, V as VerifyRequest, h as VerifyResponse, i as ResendVerificationRequest, j as ResendVerificationResponse, F as ForgotPasswordRequest, k as ForgotPasswordResponse, l as RecoverPasswordRequest, m as RecoverPasswordResponse, n as RefreshTokenRequest, o as RefreshTokenResponse } from './index-CIK2MKl9.js';
+export { p as AuthErrorCode, q as AuthState, r as ForgotPasswordFormProps, s as LoginFormProps, P as PixygonAuthProps, t as RegisterFormProps, S as SubscriptionTier, u as TokenPayload, v as VerifyFormProps } from './index-CIK2MKl9.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+declare const AuthContext: react.Context<AuthContextValue | null>;
+interface AuthProviderProps {
+    config: AuthConfig;
+    children: ReactNode;
+}
+declare function AuthProvider({ config: userConfig, children }: AuthProviderProps): react_jsx_runtime.JSX.Element;
+declare function useAuthContext(): AuthContextValue;
+
+/**
+ * Profile Sync Hook
+ * Synchronizes user profile data across Pixygon applications
+ */
+
+interface UserProfile extends User {
+    displayName?: string;
+    avatar?: string;
+    bio?: string;
+    preferences?: Record<string, unknown>;
+    linkedApps?: string[];
+    lastSyncedAt?: string;
+}
+interface UseProfileSyncReturn {
+    /** Current user profile */
+    profile: UserProfile | null;
+    /** Whether the profile is loading */
+    isLoading: boolean;
+    /** Whether the profile is syncing */
+    isSyncing: boolean;
+    /** Error if any */
+    error: Error | null;
+    /** Update profile */
+    updateProfile: (updates: Partial<UserProfile>) => Promise<void>;
+    /** Force sync profile from server */
+    syncProfile: () => Promise<void>;
+    /** Update preferences */
+    updatePreferences: (preferences: Record<string, unknown>) => Promise<void>;
+    /** Link another app to profile */
+    linkApp: (appId: string) => Promise<void>;
+}
+/**
+ * Hook to sync user profile across apps
+ */
+declare function useProfileSync(): UseProfileSyncReturn;
+
+/**
+ * @pixygon/auth - Custom Hooks
+ * Convenient hooks for accessing auth state and actions
+ */
+
+interface UseAuthReturn {
+    user: User | null;
+    status: AuthStatus;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isVerified: boolean;
+    error: AuthError | null;
+    login: ReturnType<typeof useAuthContext>['login'];
+    register: ReturnType<typeof useAuthContext>['register'];
+    logout: ReturnType<typeof useAuthContext>['logout'];
+    verify: ReturnType<typeof useAuthContext>['verify'];
+    resendVerification: ReturnType<typeof useAuthContext>['resendVerification'];
+    forgotPassword: ReturnType<typeof useAuthContext>['forgotPassword'];
+    recoverPassword: ReturnType<typeof useAuthContext>['recoverPassword'];
+    hasRole: (role: UserRole | UserRole[]) => boolean;
+}
+/**
+ * Main auth hook providing all auth state and actions
+ */
+declare function useAuth(): UseAuthReturn;
+interface UseUserReturn {
+    user: User | null;
+    isAuthenticated: boolean;
+    isVerified: boolean;
+    role: UserRole | null;
+    hasRole: (role: UserRole | UserRole[]) => boolean;
+    userId: string | null;
+    userName: string | null;
+    email: string | null;
+    profilePicture: string | null;
+    subscriptionTier: User['subscriptionTier'] | null;
+    dailyTokens: number;
+    purchasedTokens: number;
+    bonusTokens: number;
+    subscriptionTokens: number;
+    totalTokens: number;
+}
+/**
+ * Hook for accessing user data with convenient shortcuts
+ */
+declare function useUser(): UseUserReturn;
+interface UseTokenReturn {
+    accessToken: string | null;
+    refreshToken: string | null;
+    getAccessToken: () => string | null;
+    refreshTokens: () => Promise<void>;
+    isAuthenticated: boolean;
+}
+/**
+ * Hook for accessing and managing auth tokens
+ */
+declare function useToken(): UseTokenReturn;
+interface UseAuthStatusReturn {
+    status: AuthStatus;
+    isIdle: boolean;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isUnauthenticated: boolean;
+    isVerifying: boolean;
+}
+/**
+ * Hook for auth status checks
+ */
+declare function useAuthStatus(): UseAuthStatusReturn;
+interface UseRequireAuthOptions {
+    /** Redirect path when not authenticated */
+    redirectTo?: string;
+    /** Required roles (any of) */
+    roles?: UserRole[];
+    /** Callback when auth check fails */
+    onUnauthorized?: () => void;
+}
+interface UseRequireAuthReturn {
+    isAuthorized: boolean;
+    isLoading: boolean;
+    user: User | null;
+}
+/**
+ * Hook for protected routes/components
+ * Returns authorization state and user
+ */
+declare function useRequireAuth(options?: UseRequireAuthOptions): UseRequireAuthReturn;
+
+interface UseAuthErrorReturn {
+    error: AuthError | null;
+    hasError: boolean;
+    errorMessage: string | null;
+    errorCode: AuthError['code'] | null;
+    clearError: () => void;
+}
+/**
+ * Hook for auth error handling
+ */
+declare function useAuthError(): UseAuthErrorReturn;
+
+/**
+ * @pixygon/auth - Token Storage Utilities
+ * Unified storage for auth tokens across all Pixygon apps
+ */
+
+/**
+ * Create a token storage manager for a specific app
+ */
+declare function createTokenStorage(appId: string, storage?: AuthStorage): {
+    /**
+     * Get the stored access token
+     */
+    getAccessToken: () => Promise<string | null>;
+    /**
+     * Get the stored refresh token
+     */
+    getRefreshToken: () => Promise<string | null>;
+    /**
+     * Get the stored user
+     */
+    getUser: () => Promise<User | null>;
+    /**
+     * Get token expiration time
+     */
+    getExpiresAt: () => Promise<number | null>;
+    /**
+     * Check if access token is expired
+     */
+    isTokenExpired: () => Promise<boolean>;
+    /**
+     * Check if token will expire within threshold (in seconds)
+     */
+    willExpireSoon: (thresholdSeconds?: number) => Promise<boolean>;
+    /**
+     * Store tokens and user data
+     */
+    setTokens: (accessToken: string, refreshToken: string | null, expiresIn: number | null, user: User) => Promise<void>;
+    /**
+     * Update tokens after refresh
+     */
+    updateTokens: (tokens: TokenPair) => Promise<void>;
+    /**
+     * Update user data
+     */
+    updateUser: (user: User) => Promise<void>;
+    /**
+     * Clear all stored auth data
+     */
+    clear: () => Promise<void>;
+    /**
+     * Get all stored auth data
+     */
+    getAll: () => Promise<{
+        accessToken: string | null;
+        refreshToken: string | null;
+        user: any;
+        expiresAt: number | null;
+    }>;
+};
+type TokenStorage = ReturnType<typeof createTokenStorage>;
+
+/**
+ * @pixygon/auth - API Client
+ * Unified API client with automatic token injection and refresh
+ */
+
+interface AuthApiClient {
+    login: (data: LoginRequest) => Promise<LoginResponse>;
+    register: (data: RegisterRequest) => Promise<RegisterResponse>;
+    verify: (data: VerifyRequest) => Promise<VerifyResponse>;
+    resendVerification: (data: ResendVerificationRequest) => Promise<ResendVerificationResponse>;
+    forgotPassword: (data: ForgotPasswordRequest) => Promise<ForgotPasswordResponse>;
+    recoverPassword: (data: RecoverPasswordRequest) => Promise<RecoverPasswordResponse>;
+    refreshToken: (data: RefreshTokenRequest) => Promise<RefreshTokenResponse>;
+    getMe: () => Promise<User>;
+    updateProfile: (data: Partial<User>) => Promise<User>;
+    setAccessToken: (token: string | null) => void;
+    getAccessToken: () => string | null;
+    request: <T>(endpoint: string, options?: RequestInit) => Promise<T>;
+}
+declare function createAuthApiClient(config: AuthConfig, tokenStorage: TokenStorage): AuthApiClient;
+
+export { type AuthApiClient, AuthConfig, AuthContext, AuthContextValue, AuthError, AuthProvider, type AuthProviderProps, AuthStatus, AuthStorage, ForgotPasswordRequest, ForgotPasswordResponse, LoginRequest, LoginResponse, RecoverPasswordRequest, RecoverPasswordResponse, RefreshTokenRequest, RefreshTokenResponse, RegisterRequest, RegisterResponse, ResendVerificationRequest, ResendVerificationResponse, TokenPair, type TokenStorage, type UseAuthErrorReturn, type UseAuthReturn, type UseAuthStatusReturn, type UseProfileSyncReturn, type UseRequireAuthOptions, type UseRequireAuthReturn, type UseTokenReturn, type UseUserReturn, User, type UserProfile, UserRole, VerifyRequest, VerifyResponse, createAuthApiClient, createTokenStorage, useAuth, useAuthContext, useAuthError, useAuthStatus, useProfileSync, useRequireAuth, useToken, useUser };