rn-swiftauth-sdk 1.0.2 → 1.0.4

package/dist/errors/errorMapper.js

@@ -1,124 +1,86 @@
 "use strict";
+// swiftauth-sdk/src/errors/errorMapper.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapFirebaseError = void 0;
+exports.getErrorMessage = exports.isAuthException = exports.mapFirebaseError = void 0;
+const exceptions_1 = require("./exceptions");
 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 it's already our custom exception, return it
+    if (error instanceof exceptions_1.AuthException) {
+        return error;
+    }
+    // If it's not a Firebase error or doesn't have a code, return generic
     if (!error || typeof error.code !== 'string') {
-        return {
-            ...fallbackError,
-            message: error?.message || fallbackError.message
-        };
+        return new exceptions_1.UnknownAuthException(error?.message || 'An unexpected error occurred', error);
     }
     const fbError = error;
+    // Map Firebase error codes to custom exceptions
     switch (fbError.code) {
-        // Email/Password Errors
+        // Invalid Credentials
         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/user-disabled':
+            return new exceptions_1.InvalidCredentialsException(error);
+        // User Not Found
+        case 'auth/user-not-found':
+            return new exceptions_1.UserNotFoundException(error);
+        // Email Already In Use
         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/account-exists-with-different-credential':
+            return new exceptions_1.EmailAlreadyInUseException(error);
+        // Weak Password
         case 'auth/weak-password':
-            return {
-                code: types_1.AuthErrorCode.WEAK_PASSWORD,
-                message: 'Password is too weak. Please use a stronger password.',
-                originalError: error
-            };
+            return new exceptions_1.WeakPasswordException(error);
+        // Token Expired
+        case 'auth/id-token-expired':
+        case 'auth/user-token-expired':
+        case types_1.ProviderErrorCodes.USER_TOKEN_EXPIRED:
+            return new exceptions_1.TokenExpiredException(error);
+        // Network Error
         case 'auth/network-request-failed':
-            return {
-                code: types_1.AuthErrorCode.NETWORK_ERROR,
-                message: 'Network error. Please check your connection.',
-                originalError: error
-            };
+        case 'auth/timeout':
+            return new exceptions_1.NetworkException(error);
         // Google Sign-In Errors
+        case types_1.ProviderErrorCodes.GOOGLE_CANCELLED:
         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
-            };
+            return new exceptions_1.GoogleSignInCancelledException(error);
+        case types_1.ProviderErrorCodes.GOOGLE_PLAY_UNAVAILABLE:
+            return new exceptions_1.GooglePlayServicesUnavailableException(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 types_1.ProviderErrorCodes.APPLE_CANCELLED:
+            return new exceptions_1.AppleSignInCancelledException(error);
+        case types_1.ProviderErrorCodes.APPLE_NOT_SUPPORTED:
+            return new exceptions_1.AppleSignInNotSupportedException(error);
+        // Configuration Errors
+        case 'auth/operation-not-allowed':
+            return new exceptions_1.ConfigurationException('This sign-in method is not enabled. Please check your Firebase configuration.', error);
         case 'auth/unauthorized-domain':
-            return {
-                code: types_1.AuthErrorCode.UNKNOWN,
-                message: 'This domain is not authorized for OAuth operations.',
-                originalError: error
-            };
+            return new exceptions_1.ConfigurationException('This domain is not authorized for OAuth operations.', 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
-            };
+            return new exceptions_1.ConfigurationException('The OAuth configuration is invalid.', error);
+        // Default
         default:
-            return {
-                code: types_1.AuthErrorCode.UNKNOWN,
-                message: fbError.message || 'An unknown error occurred.',
-                originalError: error
-            };
+            return new exceptions_1.UnknownAuthException(fbError.message || 'An unknown error occurred.', error);
     }
 };
 exports.mapFirebaseError = mapFirebaseError;
+/**
+ * Helper function to check if an error is a specific exception type
+ */
+const isAuthException = (error, exceptionType) => {
+    return error instanceof exceptionType;
+};
+exports.isAuthException = isAuthException;
+/**
+ * Helper to extract user-friendly message from any error
+ */
+const getErrorMessage = (error) => {
+    if (error instanceof exceptions_1.AuthException) {
+        return error.message;
+    }
+    return error?.message || 'An unexpected error occurred';
+};
+exports.getErrorMessage = getErrorMessage;

package/dist/errors/exceptions.d.ts

@@ -0,0 +1,82 @@
+export declare class AuthException extends Error {
+    readonly code: string;
+    readonly originalError?: any;
+    readonly timestamp: Date;
+    constructor(message: string, code: string, originalError?: any);
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        timestamp: string;
+        originalError: any;
+    };
+}
+export declare class InvalidCredentialsException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when user account does not exist
+ */
+export declare class UserNotFoundException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when attempting to sign up with an email that's already registered
+ */
+export declare class EmailAlreadyInUseException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when password doesn't meet minimum security requirements
+ */
+export declare class WeakPasswordException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when user's authentication token has expired
+ */
+export declare class TokenExpiredException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when network connectivity issues occur
+ */
+export declare class NetworkException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when Google Sign-In is cancelled by user
+ */
+export declare class GoogleSignInCancelledException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when Apple Sign-In is cancelled by user
+ */
+export declare class AppleSignInCancelledException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when Apple Sign-In is not supported on the device
+ */
+export declare class AppleSignInNotSupportedException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown when Google Play Services are not available
+ */
+export declare class GooglePlayServicesUnavailableException extends AuthException {
+    constructor(originalError?: any);
+}
+/**
+ * Thrown for configuration errors
+ */
+export declare class ConfigurationException extends AuthException {
+    constructor(message: string, originalError?: any);
+}
+/**
+ * Generic unknown error
+ */
+export declare class UnknownAuthException extends AuthException {
+    constructor(message?: string, originalError?: any);
+}

package/dist/errors/exceptions.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownAuthException = exports.ConfigurationException = exports.GooglePlayServicesUnavailableException = exports.AppleSignInNotSupportedException = exports.AppleSignInCancelledException = exports.GoogleSignInCancelledException = exports.NetworkException = exports.TokenExpiredException = exports.WeakPasswordException = exports.EmailAlreadyInUseException = exports.UserNotFoundException = exports.InvalidCredentialsException = exports.AuthException = void 0;
+class AuthException extends Error {
+    code;
+    originalError;
+    timestamp;
+    constructor(message, code, originalError) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.originalError = originalError;
+        this.timestamp = new Date();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            timestamp: this.timestamp.toISOString(),
+            originalError: this.originalError?.code || this.originalError?.message,
+        };
+    }
+}
+exports.AuthException = AuthException;
+class InvalidCredentialsException extends AuthException {
+    constructor(originalError) {
+        super('Invalid email or password. Please check your credentials and try again.', 'auth/invalid-credentials', originalError);
+    }
+}
+exports.InvalidCredentialsException = InvalidCredentialsException;
+/**
+ * Thrown when user account does not exist
+ */
+class UserNotFoundException extends AuthException {
+    constructor(originalError) {
+        super('No account found with this email. Please sign up first.', 'auth/user-not-found', originalError);
+    }
+}
+exports.UserNotFoundException = UserNotFoundException;
+/**
+ * Thrown when attempting to sign up with an email that's already registered
+ */
+class EmailAlreadyInUseException extends AuthException {
+    constructor(originalError) {
+        super('This email is already registered. Please sign in or use a different email.', 'auth/email-already-in-use', originalError);
+    }
+}
+exports.EmailAlreadyInUseException = EmailAlreadyInUseException;
+/**
+ * Thrown when password doesn't meet minimum security requirements
+ */
+class WeakPasswordException extends AuthException {
+    constructor(originalError) {
+        super('Password is too weak. Please use at least 6 characters with a mix of letters and numbers.', 'auth/weak-password', originalError);
+    }
+}
+exports.WeakPasswordException = WeakPasswordException;
+/**
+ * Thrown when user's authentication token has expired
+ */
+class TokenExpiredException extends AuthException {
+    constructor(originalError) {
+        super('Your session has expired. Please sign in again.', 'auth/token-expired', originalError);
+    }
+}
+exports.TokenExpiredException = TokenExpiredException;
+/**
+ * Thrown when network connectivity issues occur
+ */
+class NetworkException extends AuthException {
+    constructor(originalError) {
+        super('Network error. Please check your internet connection and try again.', 'auth/network-error', originalError);
+    }
+}
+exports.NetworkException = NetworkException;
+/**
+ * Thrown when Google Sign-In is cancelled by user
+ */
+class GoogleSignInCancelledException extends AuthException {
+    constructor(originalError) {
+        super('Google Sign-In was cancelled.', 'auth/google-sign-in-cancelled', originalError);
+    }
+}
+exports.GoogleSignInCancelledException = GoogleSignInCancelledException;
+/**
+ * Thrown when Apple Sign-In is cancelled by user
+ */
+class AppleSignInCancelledException extends AuthException {
+    constructor(originalError) {
+        super('Apple Sign-In was cancelled.', 'auth/apple-sign-in-cancelled', originalError);
+    }
+}
+exports.AppleSignInCancelledException = AppleSignInCancelledException;
+/**
+ * Thrown when Apple Sign-In is not supported on the device
+ */
+class AppleSignInNotSupportedException extends AuthException {
+    constructor(originalError) {
+        super('Apple Sign-In is only available on iOS 13+ devices.', 'auth/apple-sign-in-not-supported', originalError);
+    }
+}
+exports.AppleSignInNotSupportedException = AppleSignInNotSupportedException;
+/**
+ * Thrown when Google Play Services are not available
+ */
+class GooglePlayServicesUnavailableException extends AuthException {
+    constructor(originalError) {
+        super('Google Play Services are not available. Please update Google Play Services.', 'auth/google-play-services-unavailable', originalError);
+    }
+}
+exports.GooglePlayServicesUnavailableException = GooglePlayServicesUnavailableException;
+/**
+ * Thrown for configuration errors
+ */
+class ConfigurationException extends AuthException {
+    constructor(message, originalError) {
+        super(message, 'auth/configuration-error', originalError);
+    }
+}
+exports.ConfigurationException = ConfigurationException;
+/**
+ * Generic unknown error
+ */
+class UnknownAuthException extends AuthException {
+    constructor(message = 'An unexpected error occurred.', originalError) {
+        super(message, 'auth/unknown', originalError);
+    }
+}
+exports.UnknownAuthException = UnknownAuthException;

package/dist/errors/index.d.ts

@@ -1 +1,2 @@
-export * from './errorMapper';
+export { AuthException, InvalidCredentialsException, UserNotFoundException, EmailAlreadyInUseException, WeakPasswordException, TokenExpiredException, NetworkException, GoogleSignInCancelledException, AppleSignInCancelledException, AppleSignInNotSupportedException, GooglePlayServicesUnavailableException, ConfigurationException, UnknownAuthException, } from './exceptions';
+export { mapFirebaseError, isAuthException, getErrorMessage, } from './errorMapper';

package/dist/errors/index.js

@@ -1,17 +1,21 @@
 "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);
+exports.getErrorMessage = exports.isAuthException = exports.mapFirebaseError = exports.UnknownAuthException = exports.ConfigurationException = exports.GooglePlayServicesUnavailableException = exports.AppleSignInNotSupportedException = exports.AppleSignInCancelledException = exports.GoogleSignInCancelledException = exports.NetworkException = exports.TokenExpiredException = exports.WeakPasswordException = exports.EmailAlreadyInUseException = exports.UserNotFoundException = exports.InvalidCredentialsException = exports.AuthException = void 0;
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "AuthException", { enumerable: true, get: function () { return exceptions_1.AuthException; } });
+Object.defineProperty(exports, "InvalidCredentialsException", { enumerable: true, get: function () { return exceptions_1.InvalidCredentialsException; } });
+Object.defineProperty(exports, "UserNotFoundException", { enumerable: true, get: function () { return exceptions_1.UserNotFoundException; } });
+Object.defineProperty(exports, "EmailAlreadyInUseException", { enumerable: true, get: function () { return exceptions_1.EmailAlreadyInUseException; } });
+Object.defineProperty(exports, "WeakPasswordException", { enumerable: true, get: function () { return exceptions_1.WeakPasswordException; } });
+Object.defineProperty(exports, "TokenExpiredException", { enumerable: true, get: function () { return exceptions_1.TokenExpiredException; } });
+Object.defineProperty(exports, "NetworkException", { enumerable: true, get: function () { return exceptions_1.NetworkException; } });
+Object.defineProperty(exports, "GoogleSignInCancelledException", { enumerable: true, get: function () { return exceptions_1.GoogleSignInCancelledException; } });
+Object.defineProperty(exports, "AppleSignInCancelledException", { enumerable: true, get: function () { return exceptions_1.AppleSignInCancelledException; } });
+Object.defineProperty(exports, "AppleSignInNotSupportedException", { enumerable: true, get: function () { return exceptions_1.AppleSignInNotSupportedException; } });
+Object.defineProperty(exports, "GooglePlayServicesUnavailableException", { enumerable: true, get: function () { return exceptions_1.GooglePlayServicesUnavailableException; } });
+Object.defineProperty(exports, "ConfigurationException", { enumerable: true, get: function () { return exceptions_1.ConfigurationException; } });
+Object.defineProperty(exports, "UnknownAuthException", { enumerable: true, get: function () { return exceptions_1.UnknownAuthException; } });
+var errorMapper_1 = require("./errorMapper");
+Object.defineProperty(exports, "mapFirebaseError", { enumerable: true, get: function () { return errorMapper_1.mapFirebaseError; } });
+Object.defineProperty(exports, "isAuthException", { enumerable: true, get: function () { return errorMapper_1.isAuthException; } });
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return errorMapper_1.getErrorMessage; } });

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

@@ -1,5 +1,5 @@
 import { AuthConfig } from './config.types';
-import { AuthError } from './error.types';
+import { AuthException } from '../errors';
 export declare enum AuthStatus {
     AUTHENTICATED = "AUTHENTICATED",
     UNAUTHENTICATED = "UNAUTHENTICATED",
@@ -26,10 +26,11 @@ export interface AuthContextType {
     user: User | null;
     status: AuthStatus;
     isLoading: boolean;
-    error: AuthError | null;
+    error: AuthException | null;
     config: AuthConfig;
     signInWithEmail: (options: EmailSignInOptions) => Promise<void>;
     signUpWithEmail: (options: EmailSignUpOptions) => Promise<void>;
+    sendPasswordReset: (email: string) => Promise<void>;
     signInWithGoogle: () => Promise<void>;
     signInWithApple: () => Promise<void>;
     signOut: () => Promise<void>;

package/dist/types/error.types.d.ts

@@ -13,20 +13,21 @@ export declare enum AuthErrorCode {
     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",
+    NETWORK_ERROR = "auth/network-error",
     UNKNOWN = "auth/unknown",
     CONFIG_ERROR = "auth/configuration-error",
     CANCELLED = "auth/cancelled",
-    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_CANCELLED = "APPLE_SIGN_IN_CANCELLED",
-    APPLE_SIGN_IN_FAILED = "APPLE_SIGN_IN_FAILED",
-    APPLE_SIGN_IN_NOT_SUPPORTED = "APPLE_SIGN_IN_NOT_SUPPORTED"
+    GOOGLE_SIGN_IN_CANCELLED = "auth/google-sign-in-cancelled",
+    GOOGLE_SIGN_IN_IN_PROGRESS = "auth/google-sign-in-in-progress",
+    GOOGLE_PLAY_SERVICES_NOT_AVAILABLE = "auth/google-play-services-unavailable",
+    GOOGLE_SIGN_IN_FAILED = "auth/google-sign-in-failed",
+    APPLE_SIGN_IN_CANCELLED = "auth/apple-sign-in-cancelled",
+    APPLE_SIGN_IN_FAILED = "auth/apple-sign-in-failed",
+    APPLE_SIGN_IN_NOT_SUPPORTED = "auth/apple-sign-in-not-supported"
 }
 export interface AuthError {
     code: string | ProviderErrorCodes | AuthErrorCode;
     message: string;
     originalError?: any;
 }
+export declare const isAuthError: (error: any) => error is AuthError;

package/dist/types/error.types.js

@@ -1,8 +1,6 @@
 "use strict";
-// src/types/error.types.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthErrorCode = exports.ProviderErrorCodes = void 0;
-// ✅ 1. Define Known Error Codes (Source of Truth)
+exports.isAuthError = exports.AuthErrorCode = exports.ProviderErrorCodes = void 0;
 var ProviderErrorCodes;
 (function (ProviderErrorCodes) {
     // Firebase specific
@@ -16,26 +14,35 @@ var ProviderErrorCodes;
     ProviderErrorCodes["APPLE_CANCELLED"] = "ERR_REQUEST_CANCELED";
     ProviderErrorCodes["APPLE_NOT_SUPPORTED"] = "APPLE_SIGN_IN_NOT_SUPPORTED";
 })(ProviderErrorCodes || (exports.ProviderErrorCodes = ProviderErrorCodes = {}));
-// Legacy error codes used in mapping (Keep this for backward compatibility if needed)
+// ✅ Standardized error codes (used by custom exceptions)
 var AuthErrorCode;
 (function (AuthErrorCode) {
+    // Core authentication errors
     AuthErrorCode["INVALID_CREDENTIALS"] = "auth/invalid-credentials";
     AuthErrorCode["USER_NOT_FOUND"] = "auth/user-not-found";
     AuthErrorCode["EMAIL_ALREADY_IN_USE"] = "auth/email-already-in-use";
     AuthErrorCode["WEAK_PASSWORD"] = "auth/weak-password";
     AuthErrorCode["TOKEN_EXPIRED"] = "auth/token-expired";
-    AuthErrorCode["NETWORK_ERROR"] = "auth/network-request-failed";
+    AuthErrorCode["NETWORK_ERROR"] = "auth/network-error";
     AuthErrorCode["UNKNOWN"] = "auth/unknown";
-    // Specific to SDK flow
+    // Configuration errors
     AuthErrorCode["CONFIG_ERROR"] = "auth/configuration-error";
+    // User actions
     AuthErrorCode["CANCELLED"] = "auth/cancelled";
-    // Google Sign-In Errors
-    AuthErrorCode["GOOGLE_SIGN_IN_CANCELLED"] = "GOOGLE_SIGN_IN_CANCELLED";
-    AuthErrorCode["GOOGLE_SIGN_IN_IN_PROGRESS"] = "GOOGLE_SIGN_IN_IN_PROGRESS";
-    AuthErrorCode["GOOGLE_PLAY_SERVICES_NOT_AVAILABLE"] = "GOOGLE_PLAY_SERVICES_NOT_AVAILABLE";
-    AuthErrorCode["GOOGLE_SIGN_IN_FAILED"] = "GOOGLE_SIGN_IN_FAILED";
-    // Apple Sign-In Errors
-    AuthErrorCode["APPLE_SIGN_IN_CANCELLED"] = "APPLE_SIGN_IN_CANCELLED";
-    AuthErrorCode["APPLE_SIGN_IN_FAILED"] = "APPLE_SIGN_IN_FAILED";
-    AuthErrorCode["APPLE_SIGN_IN_NOT_SUPPORTED"] = "APPLE_SIGN_IN_NOT_SUPPORTED";
+    // Google Sign-In errors
+    AuthErrorCode["GOOGLE_SIGN_IN_CANCELLED"] = "auth/google-sign-in-cancelled";
+    AuthErrorCode["GOOGLE_SIGN_IN_IN_PROGRESS"] = "auth/google-sign-in-in-progress";
+    AuthErrorCode["GOOGLE_PLAY_SERVICES_NOT_AVAILABLE"] = "auth/google-play-services-unavailable";
+    AuthErrorCode["GOOGLE_SIGN_IN_FAILED"] = "auth/google-sign-in-failed";
+    // Apple Sign-In errors
+    AuthErrorCode["APPLE_SIGN_IN_CANCELLED"] = "auth/apple-sign-in-cancelled";
+    AuthErrorCode["APPLE_SIGN_IN_FAILED"] = "auth/apple-sign-in-failed";
+    AuthErrorCode["APPLE_SIGN_IN_NOT_SUPPORTED"] = "auth/apple-sign-in-not-supported";
 })(AuthErrorCode || (exports.AuthErrorCode = AuthErrorCode = {}));
+const isAuthError = (error) => {
+    return (error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        'message' in error);
+};
+exports.isAuthError = isAuthError;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rn-swiftauth-sdk",
-    "version": "1.0.2",
+    "version": "1.0.4",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": [