@mindly/ui-components 6.6.0-dev.8 → 6.6.0

package/dist/esm/lib2/shared/providers/AuthProvider/types.d.ts

@@ -1,19 +0,0 @@
-import { CreateUserWithEmailAndPasswordOptions, LinkWithEmailAndPasswordOptions, SendPasswordResetEmailOptions, SignInResult, SignInWithEmailAndPasswordOptions, User } from '@capacitor-firebase/authentication';
-export type AuthContextType = {
-    isAuthLoading: boolean;
-    isAuthReady: boolean;
-    authUser: User | null;
-    signInAnonymously: () => Promise<SignInResult>;
-    signInWithApple: () => Promise<SignInResult>;
-    signInWithGoogle: () => Promise<SignInResult>;
-    signInWithCustomToken: (token: string) => Promise<SignInResult>;
-    signInWithEmailAndPassword: (options: SignInWithEmailAndPasswordOptions) => Promise<SignInResult>;
-    linkWithApple: () => Promise<SignInResult>;
-    linkWithGoogle: () => Promise<SignInResult>;
-    linkWithEmailAndPassword: (options: LinkWithEmailAndPasswordOptions) => Promise<SignInResult>;
-    signOut: () => Promise<void>;
-    createUserWithEmailAndPassword: (options: CreateUserWithEmailAndPasswordOptions) => Promise<SignInResult>;
-    sendPasswordResetEmail: (options: SendPasswordResetEmailOptions) => Promise<void>;
-    changePassword: (newPassword: string) => Promise<void>;
-    sendEmailVerification: () => Promise<void>;
-};

package/dist/esm/lib2/shared/utils/globalAuthState.d.ts

@@ -1,142 +0,0 @@
-/**
- * Global Authentication State Manager
- *
- * This utility class manages the authentication readiness state across the entire application.
- * It ensures that HTTP requests and other auth-dependent operations wait for authentication
- * initialization to complete before proceeding.
- *
- * ## Usage Pattern:
- *
- * 1. **UI Library Internal**: The UI library calls `setReady()` when authentication initialization
- *    is complete (e.g., after token validation, user session restoration, etc.)
- *
- * 2. **External Consumers**: Global states, HTTP interceptors, and other parts of the application
- *    use `waitForReady()` or `getIsReady()` to ensure auth is initialized before making requests
- *
- * ## Example:
- *
- * ```typescript
- * // In UI library (AuthProvider):
- * globalAuthState.setReady(); // Called after auth initialization
- *
- * // In global states or HTTP clients:
- * await globalAuthState.waitForReady(); // Wait before making authenticated requests
- *
- * // In synchronous contexts:
- * if (globalAuthState.getIsReady()) {
- *   // Proceed with auth-dependent operations
- * }
- * ```
- *
- * ## Thread Safety:
- * This class is designed to be safe for concurrent access. Multiple consumers can wait
- * for readiness simultaneously, and all will be notified when auth becomes ready.
- */
-declare class GlobalAuthState {
-    /** Internal flag tracking whether authentication is ready */
-    private isReady;
-    /** Promise that resolves when authentication becomes ready */
-    private readyPromise;
-    /** Function to resolve the readiness promise */
-    private resolveReady;
-    constructor();
-    /**
-     * Mark authentication as ready and notify all waiting consumers
-     *
-     * **INTERNAL USE ONLY**: This method should only be called by the UI library's
-     * authentication provider when auth initialization is complete.
-     *
-     * This method is idempotent - calling it multiple times has no additional effect.
-     *
-     * @example
-     * ```typescript
-     * // In AuthProvider after successful initialization
-     * globalAuthState.setReady();
-     * ```
-     */
-    setReady(): void;
-    /**
-     * Wait for authentication to be ready before proceeding
-     *
-     * **PUBLIC API**: This method is intended for use by global states, HTTP interceptors,
-     * and other parts of the application that need to ensure auth is ready before proceeding.
-     *
-     * If auth is already ready, this method returns immediately. Otherwise, it waits
-     * until `setReady()` is called.
-     *
-     * @returns Promise that resolves when authentication is ready
-     *
-     * @example
-     * ```typescript
-     * // In HTTP interceptor
-     * async function makeAuthenticatedRequest(url: string) {
-     *   await globalAuthState.waitForReady();
-     *   return fetch(url, { headers: { Authorization: getToken() } });
-     * }
-     *
-     * // In global state
-     * async function initializeUserData() {
-     *   await globalAuthState.waitForReady();
-     *   // Now safe to make authenticated API calls
-     * }
-     * ```
-     */
-    waitForReady(): Promise<void>;
-    /**
-     * Check if authentication is ready synchronously
-     *
-     * **PUBLIC API**: This method is intended for use in synchronous contexts where
-     * you need to check auth readiness without waiting.
-     *
-     * @returns `true` if authentication is ready, `false` otherwise
-     *
-     * @example
-     * ```typescript
-     * // In a synchronous context
-     * function canMakeAuthRequest(): boolean {
-     *   return globalAuthState.getIsReady();
-     * }
-     *
-     * // In conditional logic
-     * if (globalAuthState.getIsReady()) {
-     *   // Safe to access auth-dependent features
-     *   showUserDashboard();
-     * } else {
-     *   // Show loading state
-     *   showAuthLoadingSpinner();
-     * }
-     * ```
-     */
-    getIsReady(): boolean;
-    /**
-     * Reset the authentication ready state
-     *
-     * **PRIVATE METHOD**: This method is for internal use only (testing, re-initialization).
-     * It should not be called by external consumers as it can cause race conditions
-     * and unexpected behavior in production.
-     *
-     * Resets the state to unready and creates a new promise that consumers will wait on.
-     */
-    private reset;
-}
-/**
- * Global singleton instance of the authentication state manager
- *
- * This is the main interface for interacting with authentication readiness state.
- * Import and use this instance throughout your application to coordinate auth-dependent operations.
- *
- * @example
- * ```typescript
- * import { globalAuthState } from './globalAuthState';
- *
- * // Wait for auth in async contexts
- * await globalAuthState.waitForReady();
- *
- * // Check auth state synchronously
- * if (globalAuthState.getIsReady()) {
- *   // Proceed with authenticated operations
- * }
- * ```
- */
-export declare const globalAuthState: GlobalAuthState;
-export {};