@cedros/login-react 0.0.12 → 0.0.13

package/dist/hooks/useOrgs.d.ts

@@ -1,49 +0,0 @@
-import { OrgWithMembership, Organization, CreateOrgRequest, UpdateOrgRequest, Permission, OrgRole, AuthError } from '../types';
-export interface UseOrgsReturn {
-    /** All organizations the user belongs to */
-    orgs: OrgWithMembership[];
-    /** Currently active organization */
-    activeOrg: OrgWithMembership | null;
-    /** User's permissions in the active org */
-    permissions: Permission[];
-    /** User's role in the active org */
-    role: OrgRole | null;
-    /** Loading state */
-    isLoading: boolean;
-    /** Error state */
-    error: AuthError | null;
-    /** Fetch/refresh organizations list */
-    fetchOrgs: () => Promise<void>;
-    /** Switch to a different organization */
-    switchOrg: (orgId: string) => Promise<void>;
-    /** Create a new organization */
-    createOrg: (data: CreateOrgRequest) => Promise<Organization>;
-    /** Update an organization */
-    updateOrg: (orgId: string, data: UpdateOrgRequest) => Promise<Organization>;
-    /** Delete an organization */
-    deleteOrg: (orgId: string) => Promise<void>;
-    /** Check if user has a specific permission */
-    hasPermission: (permission: Permission) => boolean;
-}
-/**
- * Hook for managing organizations, memberships, and permissions.
- *
- * @example
- * ```tsx
- * function OrgSelector() {
- *   const { orgs, activeOrg, switchOrg, hasPermission } = useOrgs();
- *
- *   return (
- *     <select
- *       value={activeOrg?.id}
- *       onChange={(e) => switchOrg(e.target.value)}
- *     >
- *       {orgs.map(org => (
- *         <option key={org.id} value={org.id}>{org.name}</option>
- *       ))}
- *     </select>
- *   );
- * }
- * ```
- */
-export declare function useOrgs(): UseOrgsReturn;

package/dist/hooks/usePasswordReset.d.ts

@@ -1,32 +0,0 @@
-import { AuthError } from '../types';
-export interface UsePasswordResetReturn {
-    forgotPassword: (email: string) => Promise<void>;
-    resetPassword: (token: string, newPassword: string) => Promise<void>;
-    isLoading: boolean;
-    isSuccess: boolean;
-    error: AuthError | null;
-    clearError: () => void;
-    reset: () => void;
-    /** Number of remaining attempts before rate limiting */
-    remainingAttempts: number;
-}
-/**
- * Hook for password reset functionality.
- *
- * @example
- * ```tsx
- * function ForgotPasswordForm() {
- *   const { forgotPassword, isLoading, isSuccess, error } = usePasswordReset();
- *
- *   const handleSubmit = async (e) => {
- *     e.preventDefault();
- *     await forgotPassword(email);
- *   };
- *
- *   if (isSuccess) {
- *     return <p>Check your email for reset instructions</p>;
- *   }
- * }
- * ```
- */
-export declare function usePasswordReset(): UsePasswordResetReturn;

package/dist/hooks/usePendingRecovery.d.ts

@@ -1,34 +0,0 @@
-/**
- * Hook for pending wallet recovery management
- *
- * After wallet enrollment, if recovery mode is enabled, the server stores
- * recovery data temporarily. This hook fetches that data and allows the
- * user to acknowledge receipt (after which the data is deleted from server).
- */
-export interface UsePendingRecoveryReturn {
-    /** Whether there is pending recovery data */
-    hasPendingRecovery: boolean;
-    /** Recovery type: 'share_c' or 'full_seed' */
-    recoveryType: string | null;
-    /** Recovery phrase (base64-encoded seed) */
-    recoveryPhrase: string | null;
-    /** When the recovery data expires */
-    expiresAt: Date | null;
-    /** Fetch pending recovery data from server */
-    fetchPendingRecovery: () => Promise<void>;
-    /** Acknowledge that user has saved the recovery phrase (deletes from server) */
-    acknowledgeRecovery: () => Promise<void>;
-    /** Whether request is in progress */
-    isLoading: boolean;
-    /** Error from last request */
-    error: string | null;
-    /** Clear error */
-    clearError: () => void;
-}
-/**
- * Hook for managing pending wallet recovery data
- *
- * Use this after wallet enrollment to show the user their recovery phrase
- * and allow them to acknowledge receipt.
- */
-export declare function usePendingRecovery(): UsePendingRecoveryReturn;

package/dist/hooks/useProfile.d.ts

@@ -1,35 +0,0 @@
-import { UseProfileReturn } from '../types';
-/**
- * Hook for managing user profile operations.
- *
- * Provides methods for updating profile information and changing password.
- *
- * @example
- * ```tsx
- * function ProfileSettings() {
- *   const { isLoading, error, changePassword, clearError } = useProfile();
- *
- *   const handlePasswordChange = async () => {
- *     try {
- *       await changePassword({
- *         currentPassword: 'oldpass',
- *         newPassword: 'newpass123',
- *       });
- *       // Success - other sessions have been revoked
- *     } catch (err) {
- *       // Error is available via the error property
- *     }
- *   };
- *
- *   return (
- *     <div>
- *       {error && <p className="error">{error.message}</p>}
- *       <button onClick={handlePasswordChange} disabled={isLoading}>
- *         Change Password
- *       </button>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useProfile(): UseProfileReturn;

package/dist/hooks/useRateLimiter.d.ts

@@ -1,58 +0,0 @@
-export interface UseRateLimiterOptions {
-    /** Maximum number of attempts allowed within the window */
-    maxAttempts?: number;
-    /** Time window in milliseconds */
-    windowMs?: number;
-}
-export interface UseRateLimiterReturn {
-    /**
-     * Check if an action is allowed. Throws an error if rate limited.
-     * Call this before performing the action.
-     */
-    checkLimit: () => void;
-    /**
-     * Check if an action is allowed without throwing.
-     * Returns true if allowed, false if rate limited.
-     */
-    isAllowed: () => boolean;
-    /**
-     * Get remaining attempts in current window
-     */
-    getRemainingAttempts: () => number;
-    /**
-     * Get time until rate limit resets (in ms)
-     */
-    getTimeUntilReset: () => number;
-    /**
-     * Reset the rate limiter (e.g., after successful action)
-     */
-    reset: () => void;
-}
-/**
- * Rate limiting hook to prevent excessive API calls from the client.
- *
- * @param options - Rate limiter configuration
- * @returns Rate limiter functions
- *
- * @example
- * ```tsx
- * function LoginForm() {
- *   const { checkLimit, getRemainingAttempts } = useRateLimiter({
- *     maxAttempts: 5,
- *     windowMs: 60000, // 1 minute
- *   });
- *
- *   const handleLogin = async () => {
- *     try {
- *       checkLimit(); // Throws if rate limited
- *       await login(email, password);
- *     } catch (err) {
- *       if (err.message.includes('Too many attempts')) {
- *         // Show rate limit message
- *       }
- *     }
- *   };
- * }
- * ```
- */
-export declare function useRateLimiter(options?: UseRateLimiterOptions): UseRateLimiterReturn;

package/dist/hooks/useServerFeatures.d.ts

@@ -1,55 +0,0 @@
-/**
- * Server-side feature flags stored in system settings.
- *
- * These control which features are available in the application.
- * Unlike client-side FeatureFlags (passed to CedrosLoginProvider),
- * these can be toggled at runtime via the admin dashboard.
- */
-export interface ServerFeatures {
-    /** Enable multi-tenant organizations. Controls: Team, Invites sections */
-    organizations: boolean;
-    /** Enable Enterprise SSO for organizations */
-    sso: boolean;
-    /** Enable two-factor authentication (TOTP) */
-    mfa: boolean;
-    /** Enable embedded wallet for transaction signing */
-    walletSigning: boolean;
-    /** Enable deposits and credits system. Controls: Deposits, Withdrawals, Credit System sections */
-    credits: boolean;
-    /** Enable Cedros Pay integration. Controls: Products, Transactions, Refunds, etc. */
-    cedrosPay: boolean;
-}
-export interface UseServerFeaturesReturn {
-    /** Current feature flag states */
-    features: ServerFeatures;
-    /** Whether settings are still loading */
-    isLoading: boolean;
-    /** Error if settings failed to load */
-    error: Error | null;
-    /** Refresh feature flags from server */
-    refetch: () => Promise<void>;
-    /** Check if a specific feature is enabled */
-    isEnabled: (feature: keyof ServerFeatures) => boolean;
-}
-/**
- * Hook for reading server-side feature flags from system settings.
- *
- * Use this to conditionally show/hide features based on admin settings.
- *
- * @example
- * ```tsx
- * function AdminDashboard() {
- *   const { features, isLoading, isEnabled } = useServerFeatures();
- *
- *   if (isLoading) return <LoadingSpinner />;
- *
- *   return (
- *     <nav>
- *       {isEnabled('organizations') && <NavItem>Team</NavItem>}
- *       {isEnabled('credits') && <NavItem>Deposits</NavItem>}
- *     </nav>
- *   );
- * }
- * ```
- */
-export declare function useServerFeatures(): UseServerFeaturesReturn;

package/dist/hooks/useSessions.d.ts

@@ -1,45 +0,0 @@
-import { Session, AuthError, RevokeAllSessionsResponse } from '../types';
-export interface UseSessionsReturn {
-    /** List of active sessions */
-    sessions: Session[];
-    /** Loading state */
-    isLoading: boolean;
-    /** Error state */
-    error: AuthError | null;
-    /** Fetch/refresh sessions list */
-    fetchSessions: () => Promise<void>;
-    /** Revoke all sessions (logout everywhere) */
-    revokeAllSessions: () => Promise<RevokeAllSessionsResponse>;
-    /** Number of other active sessions (excluding current) */
-    otherSessionCount: number;
-}
-/**
- * Hook for managing user sessions across devices.
- *
- * @example
- * ```tsx
- * function SessionManager() {
- *   const { sessions, isLoading, revokeAllSessions, otherSessionCount } = useSessions();
- *
- *   return (
- *     <div>
- *       <h3>Active Sessions ({sessions.length})</h3>
- *       <ul>
- *         {sessions.map(session => (
- *           <li key={session.id}>
- *             {session.userAgent}
- *             {session.isCurrent && ' (current)'}
- *           </li>
- *         ))}
- *       </ul>
- *       {otherSessionCount > 0 && (
- *         <button onClick={revokeAllSessions}>
- *           Sign out of {otherSessionCount} other device(s)
- *         </button>
- *       )}
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useSessions(): UseSessionsReturn;

package/dist/hooks/useSettingsAutosave.d.ts

@@ -1,29 +0,0 @@
-/** Autosave status */
-export type AutosaveStatus = 'idle' | 'pending' | 'saving' | 'saved' | 'error';
-export interface UseSettingsAutosaveReturn {
-    /** Settings grouped by category */
-    settings: Record<string, import('../types').SystemSetting[]>;
-    /** Current edits (key -> value) */
-    edits: Record<string, string>;
-    /** Whether initial load is in progress */
-    isLoading: boolean;
-    /** Current autosave status */
-    autosaveStatus: AutosaveStatus;
-    /** Error message if autosave failed */
-    autosaveError: string | null;
-    /** Loading error */
-    error: Error | null;
-    /** Fetch settings from server */
-    fetchSettings: () => Promise<void>;
-    /** Handle a setting change (triggers autosave) */
-    handleChange: (key: string, value: string) => void;
-    /** Get effective value (edit or original) */
-    getEffectiveValue: (key: string) => string;
-}
-/**
- * Hook for managing system settings with autosave.
- *
- * Automatically saves changes after a debounce period.
- * Provides status feedback for the autosave process.
- */
-export declare function useSettingsAutosave(): UseSettingsAutosaveReturn;

package/dist/hooks/useSetup.d.ts

@@ -1,25 +0,0 @@
-import { UseSetupReturn } from '../types/setup';
-/**
- * Hook for first-run setup operations.
- *
- * Checks if setup is needed (no admin exists) and provides
- * ability to create the first admin user.
- *
- * @example
- * ```tsx
- * function SetupCheck() {
- *   const { status, isLoading, checkStatus, createAdmin } = useSetup();
- *
- *   useEffect(() => {
- *     checkStatus();
- *   }, [checkStatus]);
- *
- *   if (isLoading) return <Loading />;
- *   if (status?.needsSetup) {
- *     return <SetupWizard onCreateAdmin={createAdmin} />;
- *   }
- *   return <Dashboard />;
- * }
- * ```
- */
-export declare function useSetup(): UseSetupReturn;

package/dist/hooks/useSolanaAuth.d.ts

@@ -1,30 +0,0 @@
-import { AuthResponse, AuthError, ChallengeResponse } from '../types';
-export interface UseSolanaAuthReturn {
-    requestChallenge: (publicKey: string) => Promise<ChallengeResponse>;
-    signIn: (publicKey: string, signature: string, message: string) => Promise<AuthResponse>;
-    isLoading: boolean;
-    error: AuthError | null;
-    clearError: () => void;
-}
-/**
- * Hook for Solana wallet authentication.
- *
- * @example
- * ```tsx
- * function SolanaLogin() {
- *   const { requestChallenge, signIn, isLoading } = useSolanaAuth();
- *   const { publicKey, signMessage } = useWallet();
- *
- *   const handleLogin = async () => {
- *     const challenge = await requestChallenge(publicKey.toBase58());
- *     const signature = await signMessage(new TextEncoder().encode(challenge.message));
- *     const result = await signIn(
- *       publicKey.toBase58(),
- *       Buffer.from(signature).toString('base64'),
- *       challenge.message
- *     );
- *   };
- * }
- * ```
- */
-export declare function useSolanaAuth(): UseSolanaAuthReturn;

package/dist/hooks/useSsoProviders.d.ts

@@ -1,52 +0,0 @@
-export interface SsoProvider {
-    id: string;
-    orgId: string;
-    name: string;
-    issuerUrl: string;
-    clientId: string;
-    scopes: string[];
-    enabled: boolean;
-    allowRegistration: boolean;
-    emailDomain: string | null;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface CreateSsoProviderInput {
-    orgId: string;
-    name: string;
-    issuerUrl: string;
-    clientId: string;
-    clientSecret: string;
-    scopes?: string[];
-    enabled?: boolean;
-    allowRegistration?: boolean;
-    emailDomain?: string | null;
-}
-export interface UpdateSsoProviderInput {
-    name?: string;
-    issuerUrl?: string;
-    clientId?: string;
-    clientSecret?: string;
-    scopes?: string[];
-    enabled?: boolean;
-    allowRegistration?: boolean;
-    emailDomain?: string | null;
-}
-interface ListResponse {
-    providers: SsoProvider[];
-    total: number;
-    limit: number;
-    offset: number;
-}
-export declare function useSsoProviders(): {
-    providers: SsoProvider[];
-    total: number;
-    isLoading: boolean;
-    error: Error | null;
-    fetchProviders: (orgId?: string, limit?: number, offset?: number) => Promise<ListResponse>;
-    createProvider: (input: CreateSsoProviderInput) => Promise<SsoProvider>;
-    updateProvider: (id: string, input: UpdateSsoProviderInput) => Promise<SsoProvider>;
-    deleteProvider: (id: string) => Promise<void>;
-    toggleProvider: (id: string, enabled: boolean) => Promise<SsoProvider>;
-};
-export {};

package/dist/hooks/useSystemSettings.d.ts

@@ -1,47 +0,0 @@
-import { UseSystemSettingsReturn } from '../types';
-/**
- * Hook for managing system settings (admin only).
- *
- * Provides CRUD operations for system-wide configuration settings
- * stored in the database. Only accessible to system administrators.
- *
- * @example
- * ```tsx
- * function SystemSettingsPanel() {
- *   const {
- *     settings,
- *     isLoading,
- *     error,
- *     fetchSettings,
- *     updateSettings,
- *     getValue,
- *   } = useSystemSettings();
- *
- *   useEffect(() => {
- *     fetchSettings();
- *   }, [fetchSettings]);
- *
- *   const handleSave = async () => {
- *     await updateSettings([
- *       { key: 'privacy_period_secs', value: '1209600' },
- *     ]);
- *   };
- *
- *   return (
- *     <div>
- *       {Object.entries(settings).map(([category, items]) => (
- *         <section key={category}>
- *           <h3>{category}</h3>
- *           {items.map(item => (
- *             <div key={item.key}>
- *               {item.key}: {item.value}
- *             </div>
- *           ))}
- *         </section>
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useSystemSettings(): UseSystemSettingsReturn;

package/dist/hooks/useThemeManager.d.ts

@@ -1,11 +0,0 @@
-import { ThemeMode, ThemeOverrides } from '../types';
-export interface UseThemeManagerOptions {
-    theme?: ThemeMode;
-    themeOverrides?: ThemeOverrides;
-}
-/**
- * Hook that manages theme application to the document root.
- * Handles light/dark/auto themes and custom CSS variable overrides.
- * Properly cleans up styles on unmount to prevent memory leaks.
- */
-export declare function useThemeManager({ theme, themeOverrides }: UseThemeManagerOptions): void;

package/dist/hooks/useTotp.d.ts

@@ -1,52 +0,0 @@
-import { AuthError, TotpStatus, TotpSetupResponse, TotpBackupCodesResponse, TotpSetupState } from '../types';
-export interface UseTotpReturn {
-    /** Current TOTP status for the user */
-    status: TotpStatus | null;
-    /** Setup state for the enrollment flow */
-    setupState: TotpSetupState;
-    /** Setup data (secret, QR URL, backup codes) */
-    setupData: TotpSetupResponse | null;
-    /** Whether a request is in progress */
-    isLoading: boolean;
-    /** Error from the last request */
-    error: AuthError | null;
-    /** Fetch current TOTP status */
-    getStatus: () => Promise<TotpStatus>;
-    /** Start TOTP setup (generates secret and backup codes) */
-    beginSetup: () => Promise<TotpSetupResponse>;
-    /** Verify code and enable TOTP */
-    enableTotp: (code: string) => Promise<void>;
-    /** Disable TOTP (requires password confirmation) */
-    disableTotp: (password: string) => Promise<void>;
-    /** Regenerate recovery codes (requires current authenticator code) */
-    regenerateBackupCodes: (code: string) => Promise<TotpBackupCodesResponse>;
-    /** Clear error state */
-    clearError: () => void;
-    /** Reset to initial state */
-    reset: () => void;
-}
-/**
- * Hook for TOTP (Time-based One-Time Password) two-factor authentication.
- *
- * Provides methods for:
- * - Setting up TOTP with authenticator apps
- * - Enabling/disabling TOTP for the user's account
- * - Managing backup codes
- *
- * @example
- * ```tsx
- * function TotpSettings() {
- *   const { status, beginSetup, enableTotp, setupData } = useTotp();
- *
- *   if (status?.enabled) {
- *     return <p>2FA is enabled</p>;
- *   }
- *
- *   const handleSetup = async () => {
- *     const data = await beginSetup();
- *     // Show QR code from data.otpauthUri
- *   };
- * }
- * ```
- */
-export declare function useTotp(): UseTotpReturn;

package/dist/hooks/useTotpVerify.d.ts

@@ -1,38 +0,0 @@
-import { AuthError, AuthResponse, TotpVerifyState } from '../types';
-export interface UseTotpVerifyReturn {
-    /** Verification state */
-    state: TotpVerifyState;
-    /** Whether verification is in progress */
-    isLoading: boolean;
-    /** Error from the last request */
-    error: AuthError | null;
-    /** Verify MFA code during login */
-    verifyTotp: (mfaToken: string, code: string) => Promise<AuthResponse>;
-    /** Clear error state */
-    clearError: () => void;
-    /** Reset to initial state */
-    reset: () => void;
-    /** Number of remaining verification attempts before rate limiting */
-    remainingAttempts: number;
-    /** Time in ms until rate limit resets (0 if not rate limited) */
-    timeUntilReset: number;
-}
-/**
- * Hook for verifying TOTP codes during the login flow.
- *
- * Used when a user has TOTP enabled and needs to provide
- * their 6-digit code after password authentication.
- *
- * @example
- * ```tsx
- * function TotpVerifyStep({ mfaToken }) {
- *   const { verifyTotp, isLoading, error } = useTotpVerify();
- *
- *   const handleVerify = async (code: string) => {
- *     const response = await verifyTotp(mfaToken, code);
- *     // User is now authenticated
- *   };
- * }
- * ```
- */
-export declare function useTotpVerify(): UseTotpVerifyReturn;

package/dist/hooks/useTransactionSigning.d.ts

@@ -1,45 +0,0 @@
-import { UnlockCredential } from '../types/wallet';
-/** Signing method in use */
-export type SigningMethod = 'external' | 'sss' | 'none';
-/** Options for external wallet signing */
-export interface ExternalSignOptions {
-    /**
-     * Callback to sign transaction with external wallet adapter.
-     * Only called when user has external Solana wallet.
-     *
-     * @param transaction - Transaction bytes to sign
-     * @returns Signature bytes (64 bytes Ed25519)
-     */
-    onExternalSign?: (transaction: Uint8Array) => Promise<Uint8Array>;
-}
-/** Return type for useTransactionSigning hook */
-export interface UseTransactionSigningReturn {
-    /** Sign a transaction (routes to appropriate method) */
-    signTransaction: (transaction: Uint8Array, credential?: UnlockCredential) => Promise<Uint8Array>;
-    /** Which signing method is available */
-    signingMethod: SigningMethod;
-    /** Whether user can sign transactions */
-    canSign: boolean;
-    /** Whether signing is in progress */
-    isSigning: boolean;
-    /** Solana public key (from either wallet type) */
-    publicKey: string | null;
-    /** Whether user has external Solana wallet */
-    hasExternalWallet: boolean;
-    /** Whether SSS wallet is enrolled */
-    hasSssWallet: boolean;
-    /** Whether SSS wallet is unlocked (for session-based signing) */
-    isSssUnlocked: boolean;
-    /** Error from last signing attempt */
-    error: string | null;
-    /** Clear error */
-    clearError: () => void;
-}
-/**
- * Unified transaction signing hook
- *
- * Automatically routes signing requests to the appropriate method:
- * - External wallet: Uses provided callback
- * - SSS wallet: Uses server-side signing
- */
-export declare function useTransactionSigning(options?: ExternalSignOptions): UseTransactionSigningReturn;

package/dist/hooks/useWallet.d.ts

@@ -1,10 +0,0 @@
-import { WalletContextValue } from '../types/wallet';
-/**
- * Main wallet hook
- *
- * Provides wallet status, capabilities, and refresh functionality.
- * Distinguishes between external Solana wallet and SSS embedded wallet.
- *
- * Returns safe defaults when called outside CedrosLoginProvider.
- */
-export declare function useWallet(): WalletContextValue;