@cedros/login-react 0.0.12 → 0.0.14

package/dist/hooks/useInstantLink.d.ts

@@ -1,42 +0,0 @@
-import { AuthError, AuthResponse, MfaRequiredResponse } from '../types';
-export interface UseInstantLinkReturn {
-    /** Send an instant link email to the given address */
-    sendInstantLink: (email: string) => Promise<void>;
-    /** Verify an instant link token and sign in */
-    verifyInstantLink: (token: string) => Promise<AuthResponse | MfaRequiredResponse>;
-    /** Whether a request is in progress */
-    isLoading: boolean;
-    /** Whether the instant link was sent successfully */
-    isSuccess: boolean;
-    /** Error from the last request */
-    error: AuthError | null;
-    /** Clear the error state */
-    clearError: () => void;
-    /** Reset to initial state */
-    reset: () => void;
-    /** Number of remaining attempts before rate limiting */
-    remainingAttempts: number;
-}
-/**
- * Hook for instant link (passwordless) authentication.
- *
- * Sends an instant link email that allows the user to sign in
- * without entering their password.
- *
- * @example
- * ```tsx
- * function InstantLinkForm() {
- *   const { sendInstantLink, isLoading, isSuccess, error } = useInstantLink();
- *
- *   const handleSubmit = async (e) => {
- *     e.preventDefault();
- *     await sendInstantLink(email);
- *   };
- *
- *   if (isSuccess) {
- *     return <p>Check your email for the sign-in link</p>;
- *   }
- * }
- * ```
- */
-export declare function useInstantLink(): UseInstantLinkReturn;

package/dist/hooks/useInvites.d.ts

@@ -1,57 +0,0 @@
-import { Invite, OrgRole, AuthError, AcceptInviteResponse } from '../types';
-export interface UseInvitesReturn {
-    /** List of pending invites */
-    invites: Invite[];
-    /** Total pending invites available on the server */
-    total: number;
-    /** Loading state */
-    isLoading: boolean;
-    /** Error state */
-    error: AuthError | null;
-    /** Fetch/refresh invites list */
-    fetchInvites: (options?: {
-        limit?: number;
-        offset?: number;
-    }) => Promise<void>;
-    /** Create a new invite */
-    createInvite: (email: string, role?: Exclude<OrgRole, 'owner'>) => Promise<void>;
-    /** Cancel a pending invite */
-    cancelInvite: (inviteId: string) => Promise<void>;
-    /** Resend an invite email */
-    resendInvite: (inviteId: string) => Promise<void>;
-    /** Accept an invite (public) */
-    acceptInvite: (token: string) => Promise<AcceptInviteResponse>;
-}
-/**
- * Hook for managing organization invites.
- *
- * @param orgId - The organization ID to manage invites for
- *
- * @example
- * ```tsx
- * function InviteManager() {
- *   const { activeOrg } = useOrgs();
- *   const { invites, createInvite, cancelInvite, resendInvite } = useInvites(activeOrg?.id);
- *
- *   const handleInvite = async (email: string) => {
- *     await createInvite(email, 'member');
- *   };
- *
- *   return (
- *     <div>
- *       <InviteForm onSubmit={handleInvite} />
- *       <ul>
- *         {invites.map(invite => (
- *           <li key={invite.id}>
- *             {invite.email} ({invite.role})
- *             <button onClick={() => resendInvite(invite.id)}>Resend</button>
- *             <button onClick={() => cancelInvite(invite.id)}>Cancel</button>
- *           </li>
- *         ))}
- *       </ul>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useInvites(orgId: string | undefined): UseInvitesReturn;

package/dist/hooks/useMembers.d.ts

@@ -1,52 +0,0 @@
-import { Member, OrgRole, AuthError } from '../types';
-export interface UseMembersReturn {
-    /** List of members */
-    members: Member[];
-    /** Total members available on the server */
-    total: number;
-    /** Loading state */
-    isLoading: boolean;
-    /** Error state */
-    error: AuthError | null;
-    /** Fetch/refresh members list */
-    fetchMembers: (options?: {
-        limit?: number;
-        offset?: number;
-    }) => Promise<void>;
-    /** Update a member's role */
-    updateMemberRole: (userId: string, role: OrgRole) => Promise<void>;
-    /** Remove a member */
-    removeMember: (userId: string) => Promise<void>;
-}
-/**
- * Hook for managing organization members.
- *
- * @param orgId - The organization ID to manage members for
- *
- * @example
- * ```tsx
- * function MembersList() {
- *   const { activeOrg } = useOrgs();
- *   const { members, isLoading, updateMemberRole, removeMember } = useMembers(activeOrg?.id);
- *
- *   if (!activeOrg) return null;
- *
- *   return (
- *     <ul>
- *       {members.map(member => (
- *         <li key={member.id}>
- *           {member.user.name} - {member.role}
- *           <button onClick={() => updateMemberRole(member.userId, 'admin')}>
- *             Make Admin
- *           </button>
- *           <button onClick={() => removeMember(member.userId)}>
- *             Remove
- *           </button>
- *         </li>
- *       ))}
- *     </ul>
- *   );
- * }
- * ```
- */
-export declare function useMembers(orgId: string | undefined): UseMembersReturn;

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;