rn-swiftauth-sdk 1.0.0

package/src/errors/errorMapper.ts

@@ -0,0 +1,139 @@
+import { FirebaseError } from 'firebase/app';
+import { AuthError, AuthErrorCode } from '../types';
+
+export const mapFirebaseError = (error: any): AuthError => {
+  // Default fallback
+  const fallbackError: AuthError = {
+    code: 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 as FirebaseError;
+
+  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: AuthErrorCode.INVALID_CREDENTIALS,
+        message: 'Invalid email or password.',
+        originalError: error
+      };
+
+    case 'auth/email-already-in-use':
+      return {
+        code: AuthErrorCode.EMAIL_ALREADY_IN_USE,
+        message: 'This email is already registered.',
+        originalError: error
+      };
+
+    case 'auth/weak-password':
+      return {
+        code: AuthErrorCode.WEAK_PASSWORD,
+        message: 'Password is too weak. Please use a stronger password.',
+        originalError: error
+      };
+
+    case 'auth/network-request-failed':
+      return {
+        code: 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: AuthErrorCode.UNKNOWN,
+        message: 'Sign-in was cancelled.',
+        originalError: error
+      };
+
+    case 'auth/account-exists-with-different-credential':
+      return {
+        code: 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: AuthErrorCode.INVALID_CREDENTIALS,
+        message: 'The credential received is invalid. Please try again.',
+        originalError: error
+      };
+
+    case 'auth/operation-not-allowed':
+      return {
+        code: AuthErrorCode.UNKNOWN,
+        message: 'This sign-in method is not enabled. Please contact support.',
+        originalError: error
+      };
+
+    case 'auth/user-disabled':
+      return {
+        code: 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: 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: AuthErrorCode.TOKEN_EXPIRED,
+        message: 'Your session has expired. Please sign in again.',
+        originalError: error
+      };
+
+    // OAuth-Specific Errors
+    case 'auth/unauthorized-domain':
+      return {
+        code: AuthErrorCode.UNKNOWN,
+        message: 'This domain is not authorized for OAuth operations.',
+        originalError: error
+      };
+
+    case 'auth/invalid-oauth-provider':
+      return {
+        code: AuthErrorCode.UNKNOWN,
+        message: 'The OAuth provider configuration is invalid.',
+        originalError: error
+      };
+
+    case 'auth/invalid-oauth-client-id':
+      return {
+        code: AuthErrorCode.UNKNOWN,
+        message: 'The OAuth client ID is invalid.',
+        originalError: error
+      };
+
+    default:
+      return {
+        code: AuthErrorCode.UNKNOWN,
+        message: fbError.message || 'An unknown error occurred.',
+        originalError: error
+      };
+  }
+};

package/src/errors/index.ts

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

package/src/hooks/index.ts

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

package/src/hooks/useAuth.ts

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { AuthContext } from '../core/AuthContext';
+import { AuthContextType } from '../types';
+
+export const useAuth = (): AuthContextType => {
+  const context = useContext(AuthContext);
+
+  if (context === undefined) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+
+  return context;
+};

package/src/index.ts

@@ -0,0 +1,12 @@
+// src/index.ts
+
+// We will uncomment these as we build them
+export * from './core';
+// export * from './providers';
+export * from './components';
+export * from './hooks';
+export * from './errors';
+export * from './types';
+
+// Placeholder so the build doesn't fail right now
+export const SDK_VERSION = "1.0.0";

package/src/types/auth.types.ts

@@ -0,0 +1,43 @@
+// src/types/auth.types.ts
+import { AuthError } from './error.types';
+import { AuthConfig } from './config.types'; // Import config type
+
+// The specific states requested in the task
+export enum AuthStatus {
+  AUTHENTICATED = 'AUTHENTICATED',
+  UNAUTHENTICATED = 'UNAUTHENTICATED',
+  TOKEN_EXPIRED = 'TOKEN_EXPIRED',
+  LOADING = 'LOADING', // Helpful for UI spinners
+}
+
+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;
+  
+  // ✅ NEW: Explicit loading state for easier UI handling
+  isLoading: boolean; 
+  
+  error: AuthError | null;
+  
+  // ✅ NEW: Expose config so UI components can check feature flags (e.g. enableGoogle)
+  config: AuthConfig;
+
+  // Actions
+  signInWithEmail: (email: string, pass: string) => Promise<void>;
+  signUpWithEmail: (email: string, pass: string) => Promise<void>;
+  signInWithGoogle: () => Promise<void>;
+  signInWithApple: () => Promise<void>;
+  signOut: () => Promise<void>;
+  
+  // Reset error state
+  clearError: () => void;
+}

package/src/types/config.types.ts

@@ -0,0 +1,46 @@
+export interface AuthConfig {
+  // Firebase Configuration
+  apiKey: string;
+  authDomain: string;
+  projectId: string;
+  storageBucket?: string;
+  messagingSenderId?: string;
+  appId?: string;
+
+  // ✅ NEW: Allow developer to choose persistence strategy
+  // 'local' = Keep user logged in forever (Standard Mobile Behavior)
+  // 'memory' = Log user out when app closes (Banking App Behavior)
+  persistence?: 'local' | 'memory';
+
+  // Feature flags
+  enableGoogle?: boolean;
+  enableApple?: boolean;
+  enableEmail?: boolean;
+
+  // Google Sign-In Configuration
+  // Get this from Firebase Console > Authentication > Sign-in method > Google
+  googleWebClientId?: string;
+
+  // Optional: iOS Client ID (usually not needed, but available)
+  googleIOSClientId?: string;
+
+  ui?: {
+    enableGoogleAuth?: boolean;  // Default: true
+    enableAppleAuth?: boolean;   // Default: true
+    enableEmailAuth?: boolean;   // Default: true
+  };
+
+  // ✅ NEW: Control the Password UI features
+  enablePasswordHints?: boolean; // Show the "8 chars, 1 number" checklist
+}
+
+export const DEFAULT_AUTH_CONFIG: Partial<AuthConfig> = {
+  persistence: 'local',
+  ui: {
+    enableGoogleAuth: true,
+    enableAppleAuth: true,
+    enableEmailAuth: true,
+  },
+
+  enablePasswordHints: true,
+};

package/src/types/error.types.ts

@@ -0,0 +1,31 @@
+// src/types/error.types.ts
+
+export enum AuthErrorCode {
+  INVALID_CREDENTIALS = 'auth/invalid-credentials',
+  USER_NOT_FOUND = 'auth/user-not-found',
+  EMAIL_ALREADY_IN_USE = 'auth/email-already-in-use',
+  WEAK_PASSWORD = 'auth/weak-password',
+  TOKEN_EXPIRED = 'auth/token-expired',
+  NETWORK_ERROR = 'auth/network-request-failed',
+  UNKNOWN = 'auth/unknown',
+  // Specific to SDK flow
+  CONFIG_ERROR = 'auth/configuration-error',
+  CANCELLED = 'auth/cancelled',
+
+  // Google Sign-In Errors
+  GOOGLE_SIGN_IN_CANCELLED = 'GOOGLE_SIGN_IN_CANCELLED',
+  GOOGLE_SIGN_IN_IN_PROGRESS = 'GOOGLE_SIGN_IN_IN_PROGRESS',
+  GOOGLE_PLAY_SERVICES_NOT_AVAILABLE = 'GOOGLE_PLAY_SERVICES_NOT_AVAILABLE',
+  GOOGLE_SIGN_IN_FAILED = 'GOOGLE_SIGN_IN_FAILED',
+
+  // Apple Sign-In Errors
+  APPLE_SIGN_IN_CANCELLED = 'APPLE_SIGN_IN_CANCELLED',
+  APPLE_SIGN_IN_FAILED = 'APPLE_SIGN_IN_FAILED',
+  APPLE_SIGN_IN_NOT_SUPPORTED = 'APPLE_SIGN_IN_NOT_SUPPORTED',
+}
+
+export interface AuthError {
+  code: AuthErrorCode;
+  message: string;
+  originalError?: any; // To store the raw Firebase error for debugging
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+// src/types/index.ts
+export * from './auth.types';
+export * from './config.types';
+export * from './error.types';
+export * from './ui.types';

package/src/types/ui.types.ts

@@ -0,0 +1,26 @@
+import { ViewStyle, TextStyle } from 'react-native';
+
+export interface AuthScreenStyles {
+  // ... existing styles (container, header, etc.)
+  container?: ViewStyle;
+  header?: ViewStyle;
+  footer?: ViewStyle;
+  title?: TextStyle;
+  subtitle?: TextStyle;
+  footerText?: TextStyle;
+  linkText?: TextStyle;
+  errorText?: TextStyle;
+  input?: TextStyle;
+  button?: ViewStyle;
+  buttonText?: TextStyle;
+  loadingIndicatorColor?: string;
+
+  // ✅ NEW: Password Specific Styles
+  inputContainer?: ViewStyle;   // Wrapper for Input + Eye Button
+  eyeIcon?: TextStyle;          // Style for the "Show/Hide" text
+  
+  // Hint List Styles
+  hintContainer?: ViewStyle;    // Wrapper for the list
+  hintText?: TextStyle;         // The text of the requirement
+  hintTextMet?: TextStyle;      // Style when requirement is met (e.g., green)
+}

package/src/utils/validation.ts

@@ -0,0 +1,20 @@
+// src/utils/validation.ts
+
+export const validateEmail = (email: string): string | null => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!email) return "Email is required.";
+  if (!emailRegex.test(email)) return "Please enter a valid email address.";
+  return null;
+};
+
+export const validatePasswordLogin = (password: string): string | null => {
+  if (!password) return "Password is required.";
+  return null;
+};
+
+export const validatePasswordSignup = (password: string): string | null => {
+  if (!password) return "Password is required.";
+  if (password.length < 6) return "Password must be at least 6 characters.";
+  if (!/\d/.test(password)) return "Password must contain at least one number.";
+  return null;
+};