rn-swiftauth-sdk 1.0.0

package/dist/core/AuthProvider.js

@@ -0,0 +1,350 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProvider = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const app_1 = require("firebase/app");
+// Firebase Auth
+const auth_1 = require("firebase/auth");
+// The Hack: Import for getReactNativePersistence
+const firebaseAuth = __importStar(require("firebase/auth"));
+// @ts-ignore
+const getReactNativePersistence = firebaseAuth.getReactNativePersistence;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+// PROPER GOOGLE SIGN-IN
+const google_signin_1 = require("@react-native-google-signin/google-signin");
+// Apple Sign-In (Expo)
+const AppleAuthentication = __importStar(require("expo-apple-authentication"));
+const Crypto = __importStar(require("expo-crypto"));
+const errors_1 = require("../errors");
+const AuthContext_1 = require("./AuthContext");
+const types_1 = require("../types");
+const AuthProvider = ({ config, children }) => {
+    const [user, setUser] = (0, react_1.useState)(null);
+    const [status, setStatus] = (0, react_1.useState)(types_1.AuthStatus.LOADING);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [firebaseAuthInstance, setFirebaseAuthInstance] = (0, react_1.useState)(null);
+    // ✅ NEW: Explicit loading state for initial app load vs action loading
+    const [isDataLoading, setIsDataLoading] = (0, react_1.useState)(true);
+    (0, react_1.useEffect)(() => {
+        let app;
+        let auth;
+        if (!(0, app_1.getApps)().length) {
+            // 1. Initialize App
+            app = (0, app_1.initializeApp)({
+                apiKey: config.apiKey,
+                authDomain: config.authDomain,
+                projectId: config.projectId,
+                storageBucket: config.storageBucket,
+                messagingSenderId: config.messagingSenderId,
+                appId: config.appId,
+            });
+            // 2. Select Persistence Strategy
+            const selectedPersistence = config.persistence === 'memory'
+                ? auth_1.inMemoryPersistence
+                : getReactNativePersistence(async_storage_1.default);
+            // 3. Initialize Auth
+            auth = (0, auth_1.initializeAuth)(app, {
+                persistence: selectedPersistence
+            });
+        }
+        else {
+            app = (0, app_1.getApp)();
+            auth = (0, auth_1.getAuth)(app);
+        }
+        setFirebaseAuthInstance(auth);
+        // 4. Configure Google Sign-In if enabled
+        if (config.enableGoogle && config.googleWebClientId) {
+            try {
+                google_signin_1.GoogleSignin.configure({
+                    webClientId: config.googleWebClientId,
+                    offlineAccess: true,
+                    iosClientId: config.googleIOSClientId, // Optional
+                });
+                console.log('✅ Google Sign-In configured successfully');
+            }
+            catch (err) {
+                console.error('❌ Google Sign-In configuration failed:', err);
+            }
+        }
+        const unsubscribe = (0, auth_1.onAuthStateChanged)(auth, async (fbUser) => {
+            try {
+                if (fbUser) {
+                    try {
+                        // Force token refresh to ensure validity on load
+                        const token = await fbUser.getIdToken(true);
+                        setUser({
+                            uid: fbUser.uid,
+                            email: fbUser.email,
+                            displayName: fbUser.displayName,
+                            photoURL: fbUser.photoURL,
+                            emailVerified: fbUser.emailVerified,
+                            token: token
+                        });
+                        setStatus(types_1.AuthStatus.AUTHENTICATED);
+                    }
+                    catch (tokenError) {
+                        console.error('Token retrieval error:', tokenError);
+                        if (tokenError.code === 'auth/user-token-expired' || tokenError.code === 'auth/null-user') {
+                            setStatus(types_1.AuthStatus.TOKEN_EXPIRED);
+                        }
+                        else {
+                            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+                        }
+                        setUser(null);
+                    }
+                }
+                else {
+                    setUser(null);
+                    setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+                }
+            }
+            catch (err) {
+                console.error("Auth State Error:", err);
+                setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            }
+            finally {
+                // ✅ Stop initial loading spinner once Firebase has checked storage
+                setIsDataLoading(false);
+            }
+        }, (err) => {
+            console.error("Auth State Error:", err);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            setIsDataLoading(false);
+        });
+        return () => unsubscribe();
+    }, [config]);
+    // Email/Password Sign In
+    const signInWithEmail = async (email, pass) => {
+        if (!firebaseAuthInstance)
+            return;
+        try {
+            setError(null);
+            setStatus(types_1.AuthStatus.LOADING);
+            await (0, auth_1.signInWithEmailAndPassword)(firebaseAuthInstance, email, pass);
+        }
+        catch (err) {
+            const mappedError = (0, errors_1.mapFirebaseError)(err);
+            setError(mappedError);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            throw mappedError;
+        }
+    };
+    // Email/Password Sign Up
+    const signUpWithEmail = async (email, pass) => {
+        if (!firebaseAuthInstance)
+            return;
+        try {
+            setError(null);
+            setStatus(types_1.AuthStatus.LOADING);
+            await (0, auth_1.createUserWithEmailAndPassword)(firebaseAuthInstance, email, pass);
+        }
+        catch (err) {
+            const mappedError = (0, errors_1.mapFirebaseError)(err);
+            setError(mappedError);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            throw mappedError;
+        }
+    };
+    // PROPER GOOGLE SIGN-IN using @react-native-google-signin/google-signin
+    const signInWithGoogle = async () => {
+        if (!firebaseAuthInstance) {
+            throw new Error('Firebase not initialized');
+        }
+        if (!config.enableGoogle || !config.googleWebClientId) {
+            const configError = {
+                code: types_1.AuthErrorCode.CONFIG_ERROR,
+                message: 'Google Sign-In is not enabled or configured. Please add googleWebClientId to your AuthConfig.',
+            };
+            setError(configError);
+            throw configError;
+        }
+        try {
+            setError(null);
+            setStatus(types_1.AuthStatus.LOADING);
+            await google_signin_1.GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true });
+            const userInfo = await google_signin_1.GoogleSignin.signIn();
+            const idToken = userInfo.data?.idToken;
+            if (!idToken) {
+                throw new Error('No ID token received from Google Sign-In');
+            }
+            const credential = auth_1.GoogleAuthProvider.credential(idToken);
+            await (0, auth_1.signInWithCredential)(firebaseAuthInstance, credential);
+            console.log('✅ Google Sign-In successful');
+        }
+        catch (err) {
+            console.error('❌ Google Sign-In Error:', err);
+            let mappedError;
+            if (err.code === 'SIGN_IN_CANCELLED') {
+                mappedError = {
+                    code: types_1.AuthErrorCode.GOOGLE_SIGN_IN_CANCELLED,
+                    message: 'Google Sign-In was cancelled',
+                    originalError: err
+                };
+                // Reset status if cancelled, don't leave it loading
+                setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+                return;
+            }
+            else if (err.code === 'IN_PROGRESS') {
+                mappedError = {
+                    code: types_1.AuthErrorCode.GOOGLE_SIGN_IN_IN_PROGRESS,
+                    message: 'Google Sign-In is already in progress',
+                    originalError: err
+                };
+            }
+            else if (err.code === 'PLAY_SERVICES_NOT_AVAILABLE') {
+                mappedError = {
+                    code: types_1.AuthErrorCode.GOOGLE_PLAY_SERVICES_NOT_AVAILABLE,
+                    message: 'Google Play Services are not available. Please update Google Play Services.',
+                    originalError: err
+                };
+            }
+            else {
+                mappedError = (0, errors_1.mapFirebaseError)(err);
+            }
+            setError(mappedError);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            throw mappedError;
+        }
+    };
+    // Apple Sign-In using expo-apple-authentication
+    const signInWithApple = async () => {
+        if (!firebaseAuthInstance) {
+            throw new Error('Firebase not initialized');
+        }
+        if (react_native_1.Platform.OS !== 'ios') {
+            const platformError = {
+                code: types_1.AuthErrorCode.APPLE_SIGN_IN_NOT_SUPPORTED,
+                message: 'Apple Sign-In is only available on iOS devices',
+            };
+            setError(platformError);
+            throw platformError;
+        }
+        const isAvailable = await AppleAuthentication.isAvailableAsync();
+        if (!isAvailable) {
+            const availabilityError = {
+                code: types_1.AuthErrorCode.APPLE_SIGN_IN_NOT_SUPPORTED,
+                message: 'Apple Sign-In is not available on this device (requires iOS 13+)',
+            };
+            setError(availabilityError);
+            throw availabilityError;
+        }
+        try {
+            setError(null);
+            setStatus(types_1.AuthStatus.LOADING);
+            const nonce = Math.random().toString(36).substring(2, 10);
+            const hashedNonce = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, nonce);
+            const appleCredential = await AppleAuthentication.signInAsync({
+                requestedScopes: [
+                    AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+                    AppleAuthentication.AppleAuthenticationScope.EMAIL,
+                ],
+                nonce: hashedNonce,
+            });
+            const { identityToken } = appleCredential;
+            if (!identityToken) {
+                throw new Error('No identity token received from Apple');
+            }
+            const provider = new auth_1.OAuthProvider('apple.com');
+            const credential = provider.credential({
+                idToken: identityToken,
+                rawNonce: nonce,
+            });
+            await (0, auth_1.signInWithCredential)(firebaseAuthInstance, credential);
+            console.log('✅ Apple Sign-In successful');
+        }
+        catch (err) {
+            console.error('❌ Apple Sign-In Error:', err);
+            if (err.code === 'ERR_REQUEST_CANCELED') {
+                const cancelError = {
+                    code: types_1.AuthErrorCode.APPLE_SIGN_IN_CANCELLED,
+                    message: 'Apple Sign-In was cancelled',
+                    originalError: err
+                };
+                setError(cancelError);
+                setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+                return;
+            }
+            const mappedError = (0, errors_1.mapFirebaseError)(err);
+            setError(mappedError);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+            throw mappedError;
+        }
+    };
+    // Sign Out
+    const signOut = async () => {
+        try {
+            if (firebaseAuthInstance) {
+                await firebaseAuthInstance.signOut();
+            }
+            if (config.enableGoogle) {
+                try {
+                    await google_signin_1.GoogleSignin.signOut();
+                }
+                catch (googleSignOutError) {
+                    console.log('Google sign-out skipped or failed:', googleSignOutError);
+                }
+            }
+            console.log('✅ Sign out successful');
+        }
+        catch (err) {
+            console.error('❌ Sign out error:', err);
+            setUser(null);
+            setStatus(types_1.AuthStatus.UNAUTHENTICATED);
+        }
+    };
+    const clearError = () => setError(null);
+    const value = (0, react_1.useMemo)(() => ({
+        user,
+        status,
+        // ✅ NEW: Combine internal loading with AuthStatus
+        isLoading: isDataLoading || status === types_1.AuthStatus.LOADING,
+        error,
+        // ✅ NEW: Expose config for UI to read
+        config,
+        signInWithEmail,
+        signUpWithEmail,
+        signInWithGoogle,
+        signInWithApple,
+        signOut,
+        clearError
+    }), [user, status, isDataLoading, error, config, firebaseAuthInstance]);
+    return (react_1.default.createElement(AuthContext_1.AuthContext.Provider, { value: value }, children));
+};
+exports.AuthProvider = AuthProvider;

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AuthContext';
+export * from './AuthProvider';

package/dist/core/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AuthContext"), exports);
+__exportStar(require("./AuthProvider"), exports);

package/dist/errors/errorMapper.d.ts

@@ -0,0 +1,2 @@
+import { AuthError } from '../types';
+export declare const mapFirebaseError: (error: any) => AuthError;

package/dist/errors/errorMapper.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFirebaseError = void 0;
+const types_1 = require("../types");
+const mapFirebaseError = (error) => {
+    // Default fallback
+    const fallbackError = {
+        code: types_1.AuthErrorCode.UNKNOWN,
+        message: 'An unexpected error occurred',
+        originalError: error,
+    };
+    // If it's not a Firebase error, return generic
+    if (!error || typeof error.code !== 'string') {
+        return {
+            ...fallbackError,
+            message: error?.message || fallbackError.message
+        };
+    }
+    const fbError = error;
+    switch (fbError.code) {
+        // Email/Password Errors
+        case 'auth/invalid-email':
+        case 'auth/user-not-found':
+        case 'auth/wrong-password':
+        case 'auth/invalid-credential':
+            return {
+                code: types_1.AuthErrorCode.INVALID_CREDENTIALS,
+                message: 'Invalid email or password.',
+                originalError: error
+            };
+        case 'auth/email-already-in-use':
+            return {
+                code: types_1.AuthErrorCode.EMAIL_ALREADY_IN_USE,
+                message: 'This email is already registered.',
+                originalError: error
+            };
+        case 'auth/weak-password':
+            return {
+                code: types_1.AuthErrorCode.WEAK_PASSWORD,
+                message: 'Password is too weak. Please use a stronger password.',
+                originalError: error
+            };
+        case 'auth/network-request-failed':
+            return {
+                code: types_1.AuthErrorCode.NETWORK_ERROR,
+                message: 'Network error. Please check your connection.',
+                originalError: error
+            };
+        // Google Sign-In Errors
+        case 'auth/popup-closed-by-user':
+        case 'auth/cancelled-popup-request':
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: 'Sign-in was cancelled.',
+                originalError: error
+            };
+        case 'auth/account-exists-with-different-credential':
+            return {
+                code: types_1.AuthErrorCode.EMAIL_ALREADY_IN_USE,
+                message: 'An account already exists with this email using a different sign-in method.',
+                originalError: error
+            };
+        case 'auth/invalid-credential':
+            return {
+                code: types_1.AuthErrorCode.INVALID_CREDENTIALS,
+                message: 'The credential received is invalid. Please try again.',
+                originalError: error
+            };
+        case 'auth/operation-not-allowed':
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: 'This sign-in method is not enabled. Please contact support.',
+                originalError: error
+            };
+        case 'auth/user-disabled':
+            return {
+                code: types_1.AuthErrorCode.INVALID_CREDENTIALS,
+                message: 'This account has been disabled.',
+                originalError: error
+            };
+        // Apple Sign-In Errors
+        case 'auth/invalid-verification-code':
+        case 'auth/invalid-verification-id':
+            return {
+                code: types_1.AuthErrorCode.INVALID_CREDENTIALS,
+                message: 'The verification code is invalid. Please try again.',
+                originalError: error
+            };
+        // Token Expiration
+        case 'auth/id-token-expired':
+        case 'auth/user-token-expired':
+            return {
+                code: types_1.AuthErrorCode.TOKEN_EXPIRED,
+                message: 'Your session has expired. Please sign in again.',
+                originalError: error
+            };
+        // OAuth-Specific Errors
+        case 'auth/unauthorized-domain':
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: 'This domain is not authorized for OAuth operations.',
+                originalError: error
+            };
+        case 'auth/invalid-oauth-provider':
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: 'The OAuth provider configuration is invalid.',
+                originalError: error
+            };
+        case 'auth/invalid-oauth-client-id':
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: 'The OAuth client ID is invalid.',
+                originalError: error
+            };
+        default:
+            return {
+                code: types_1.AuthErrorCode.UNKNOWN,
+                message: fbError.message || 'An unknown error occurred.',
+                originalError: error
+            };
+    }
+};
+exports.mapFirebaseError = mapFirebaseError;

package/dist/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './errorMapper';

package/dist/errors/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errorMapper"), exports);

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useAuth';

package/dist/hooks/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useAuth"), exports);

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,2 @@
+import { AuthContextType } from '../types';
+export declare const useAuth: () => AuthContextType;

package/dist/hooks/useAuth.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuth = void 0;
+const react_1 = require("react");
+const AuthContext_1 = require("../core/AuthContext");
+const useAuth = () => {
+    const context = (0, react_1.useContext)(AuthContext_1.AuthContext);
+    if (context === undefined) {
+        throw new Error('useAuth must be used within an AuthProvider');
+    }
+    return context;
+};
+exports.useAuth = useAuth;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './core';
+export * from './components';
+export * from './hooks';
+export * from './errors';
+export * from './types';
+export declare const SDK_VERSION = "1.0.0";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+// src/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = void 0;
+// We will uncomment these as we build them
+__exportStar(require("./core"), exports);
+// export * from './providers';
+__exportStar(require("./components"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./types"), exports);
+// Placeholder so the build doesn't fail right now
+exports.SDK_VERSION = "1.0.0";

package/dist/types/auth.types.d.ts

@@ -0,0 +1,29 @@
+import { AuthError } from './error.types';
+import { AuthConfig } from './config.types';
+export declare enum AuthStatus {
+    AUTHENTICATED = "AUTHENTICATED",
+    UNAUTHENTICATED = "UNAUTHENTICATED",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    LOADING = "LOADING"
+}
+export interface User {
+    uid: string;
+    email: string | null;
+    displayName: string | null;
+    photoURL: string | null;
+    emailVerified: boolean;
+    token?: string;
+}
+export interface AuthContextType {
+    user: User | null;
+    status: AuthStatus;
+    isLoading: boolean;
+    error: AuthError | null;
+    config: AuthConfig;
+    signInWithEmail: (email: string, pass: string) => Promise<void>;
+    signUpWithEmail: (email: string, pass: string) => Promise<void>;
+    signInWithGoogle: () => Promise<void>;
+    signInWithApple: () => Promise<void>;
+    signOut: () => Promise<void>;
+    clearError: () => void;
+}

package/dist/types/auth.types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthStatus = void 0;
+// The specific states requested in the task
+var AuthStatus;
+(function (AuthStatus) {
+    AuthStatus["AUTHENTICATED"] = "AUTHENTICATED";
+    AuthStatus["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+    AuthStatus["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    AuthStatus["LOADING"] = "LOADING";
+})(AuthStatus || (exports.AuthStatus = AuthStatus = {}));

package/dist/types/config.types.d.ts

@@ -0,0 +1,21 @@
+export interface AuthConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+    persistence?: 'local' | 'memory';
+    enableGoogle?: boolean;
+    enableApple?: boolean;
+    enableEmail?: boolean;
+    googleWebClientId?: string;
+    googleIOSClientId?: string;
+    ui?: {
+        enableGoogleAuth?: boolean;
+        enableAppleAuth?: boolean;
+        enableEmailAuth?: boolean;
+    };
+    enablePasswordHints?: boolean;
+}
+export declare const DEFAULT_AUTH_CONFIG: Partial<AuthConfig>;

package/dist/types/config.types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AUTH_CONFIG = void 0;
+exports.DEFAULT_AUTH_CONFIG = {
+    persistence: 'local',
+    ui: {
+        enableGoogleAuth: true,
+        enableAppleAuth: true,
+        enableEmailAuth: true,
+    },
+    enablePasswordHints: true,
+};