@passkeyme/react-auth 1.0.0 → 1.1.1

package/dist/index.esm.js

@@ -1,11 +1,351 @@
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import React, { createContext, useContext, useState, useEffect, useCallback, useMemo, Profiler, useRef, lazy, Suspense, Component } from 'react';
-import { PasskeymeProvider as PasskeymeProvider$1, usePasskeyme } from '@passkeyme/react-core';
-export { usePasskeyme, usePasskeymeContext } from '@passkeyme/react-core';
-import { WebPasskeySDK, PasskeymeError, PasskeymeErrorCode } from '@passkeyme/auth';
+import React, { createContext, useContext, useCallback, useState, useEffect, useMemo, Profiler, useRef, lazy, Suspense, Component } from 'react';
+import { PasskeymeError, PasskeymeErrorCode, PasskeymeAuth, WebPasskeySDK } from '@passkeyme/auth';
 export { ErrorHandler, PasskeymeError, PasskeymeErrorCode } from '@passkeyme/auth';
 import { createPortal } from 'react-dom';
 
+/**
+ * React Context Provider for PasskeyMe Authentication (Core)
+ * This is the shared provider for React and React Native
+ */
+const PasskeymeContext = createContext(null);
+const usePasskeymeContext = () => {
+    const context = useContext(PasskeymeContext);
+    if (!context) {
+        throw new Error("usePasskeymeContext must be used within a PasskeymeProvider");
+    }
+    return context;
+};
+const PasskeymeProvider$1 = ({ config, children, loadingComponent = null, errorComponent, onAuthChange, onError, }) => {
+    const [auth] = useState(() => new PasskeymeAuth(config));
+    const [authState, setAuthState] = useState({
+        user: null,
+        loading: true,
+        error: null,
+        isAuthenticated: false,
+    });
+    const [authLoading, setAuthLoading] = useState(false);
+    const [appConfig, setAppConfig] = useState(null);
+    useEffect(() => {
+        // Subscribe to state changes using the new subscription system
+        const unsubscribeState = auth.subscribe((newState) => {
+            setAuthState(newState);
+            // Call auth change callback
+            if (onAuthChange) {
+                onAuthChange(newState.user);
+            }
+            // Call error callback
+            if (newState.error && onError) {
+                onError(newState.error);
+            }
+        });
+        // Set up event listener for additional auth events
+        const unsubscribeEvents = auth.addEventListener((event) => {
+            // Handle specific events
+            switch (event.type) {
+                case "login":
+                    if (onAuthChange && event.user) {
+                        onAuthChange(event.user);
+                    }
+                    break;
+                case "logout":
+                    if (onAuthChange) {
+                        onAuthChange(null);
+                    }
+                    break;
+                case "error":
+                    if (onError && event.error) {
+                        onError(event.error);
+                    }
+                    break;
+            }
+        });
+        // Initialize auth
+        const initAuth = async () => {
+            try {
+                await auth.init();
+                // Load app configuration
+                try {
+                    const config = await auth.getAppConfig();
+                    setAppConfig(config);
+                }
+                catch (configError) {
+                    console.warn("Failed to load app configuration:", configError);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : "Authentication initialization failed";
+                if (onError) {
+                    onError(errorMessage);
+                }
+            }
+        };
+        initAuth();
+        // Cleanup
+        return () => {
+            unsubscribeState();
+            unsubscribeEvents();
+        };
+    }, [auth, onAuthChange, onError]);
+    const contextValue = {
+        auth,
+        user: authState.user,
+        loading: authState.loading,
+        error: authState.error,
+        isAuthenticated: authState.isAuthenticated,
+        authLoading,
+        setAuthLoading,
+        config,
+        appConfig,
+    };
+    // Show loading component if provided
+    if (authState.loading && loadingComponent) {
+        return React.createElement(React.Fragment, null, loadingComponent);
+    }
+    // Show error component if provided
+    if (authState.error && !authState.isAuthenticated && errorComponent) {
+        return React.createElement(React.Fragment, null, errorComponent(authState.error));
+    }
+    return (React.createElement(PasskeymeContext.Provider, { value: contextValue }, children));
+};
+
+/**
+ * Core React hooks for PasskeyMe Authentication
+ * Shared between React and React Native
+ */
+// Simple debug function for core package
+function debugLog$1(config, ...args) {
+    if (config.debug) {
+        console.log("[PasskeymeAuth]", ...args);
+    }
+}
+const usePasskeyme = () => {
+    const { auth, user, loading, error, isAuthenticated, authLoading, setAuthLoading, config, } = usePasskeymeContext();
+    if (!auth) {
+        throw new Error("PasskeyMe auth instance not available");
+    }
+    const redirectToLogin = useCallback((options) => {
+        return auth.redirectToLogin(options);
+    }, [auth]);
+    const redirectToOAuth = useCallback((provider, redirectUri) => {
+        return auth.redirectToOAuth(provider, redirectUri);
+    }, [auth]);
+    const handleAuthCallback = useCallback(async () => {
+        return auth.handleAuthCallback();
+    }, [auth]);
+    const handleCallback = useCallback(async () => {
+        return auth.handleCallback();
+    }, [auth]);
+    const handleTokenCallback = useCallback(async (token) => {
+        return auth.handleTokenCallback(token);
+    }, [auth]);
+    const logout = useCallback(async () => {
+        return auth.logout();
+    }, [auth]);
+    const getAccessToken = useCallback(async () => {
+        return auth.getAccessToken();
+    }, [auth]);
+    const refreshToken = useCallback(async () => {
+        return auth.refreshToken();
+    }, [auth]);
+    const getBaseUrl = useCallback(() => {
+        return auth.getBaseUrl();
+    }, [auth]);
+    const getAppId = useCallback(() => {
+        return auth.getAppId();
+    }, [auth]);
+    const isPasskeySupported = useCallback(() => {
+        return auth.isPasskeySupported();
+    }, [auth]);
+    const hasStoredPasskeys = useCallback(async (username) => {
+        return await auth.hasStoredPasskeys(username);
+    }, [auth]);
+    const passkeyLogin = useCallback(async (username, apiKey) => {
+        return auth.passkeyLogin(username, apiKey);
+    }, [auth]);
+    const smartLogin = useCallback(async (username, apiKey) => {
+        return auth.smartLogin(username, apiKey);
+    }, [auth]);
+    const getAppConfig = useCallback(async () => {
+        return auth.getAppConfig();
+    }, [auth]);
+    const triggerPasskeymeAuth = useCallback(async (options = {}) => {
+        var _a, _b;
+        const { username, apiKey, mode = "hosted", onSuccess, onError, onOAuthRequired, showNotifications = false, // Default to false for core package
+        forcePasskeyOnly = false, } = options;
+        debugLog$1(config, "triggerPasskeymeAuth", "Starting authentication with options:", {
+            username: username || "(discoverable)",
+            hasApiKey: !!(apiKey ||
+                config.passkeyApiKey ||
+                ((_a = config.passkey) === null || _a === void 0 ? void 0 : _a.apiKey)),
+            mode,
+            forcePasskeyOnly,
+            showNotifications,
+            isPasskeySupported: auth.isPasskeySupported(),
+            // Note: hasStoredPasskeys is now async, so we can't include it in this sync log
+        });
+        try {
+            setAuthLoading(true);
+            // Get effective API key
+            const effectiveApiKey = apiKey || config.passkeyApiKey || ((_b = config.passkey) === null || _b === void 0 ? void 0 : _b.apiKey);
+            if (forcePasskeyOnly) {
+                // Force passkey-only authentication
+                debugLog$1(config, "triggerPasskeymeAuth", "Force passkey-only mode");
+                if (!effectiveApiKey) {
+                    throw new Error("API key required for passkey authentication");
+                }
+                const result = await auth.passkeyLogin(username || undefined, effectiveApiKey);
+                debugLog$1(config, "triggerPasskeymeAuth", "Passkey-only authentication successful");
+                if (onSuccess) {
+                    onSuccess(result, "passkey");
+                }
+            }
+            else {
+                // Try passkey authentication first, then handle fallback based on mode
+                try {
+                    debugLog$1(config, "triggerPasskeymeAuth", "Attempting passkey authentication");
+                    // Validate that we have an API key for passkey authentication
+                    if (!effectiveApiKey) {
+                        debugLog$1(config, "triggerPasskeymeAuth", "No API key available for passkey auth, skipping to fallback");
+                        throw new Error("No API key available for passkey authentication");
+                    }
+                    let authUsername = username;
+                    // If no username provided, let smartLogin handle the logic
+                    // (it will check app config, localStorage, discoverable credentials, etc.)
+                    if (!authUsername) {
+                        debugLog$1(config, "triggerPasskeymeAuth", "No username provided, letting smartLogin handle auto-detection");
+                    }
+                    // Attempt smart passkey authentication (handles localStorage, discoverable credentials, etc.)
+                    debugLog$1(config, "triggerPasskeymeAuth", "Calling smartLogin with username:", authUsername || "(auto-detect)");
+                    const result = await auth.smartLogin(authUsername, effectiveApiKey);
+                    debugLog$1(config, "triggerPasskeymeAuth", "Smart authentication result:", result);
+                    if (result.method === "passkey" && result.user) {
+                        debugLog$1(config, "triggerPasskeymeAuth", "Passkey authentication successful");
+                        if (onSuccess) {
+                            onSuccess(result.user, "passkey");
+                        }
+                    }
+                    else {
+                        // smartLogin returned redirect method, which means it already redirected
+                        debugLog$1(config, "triggerPasskeymeAuth", "smartLogin redirected to hosted auth");
+                        return;
+                    }
+                }
+                catch (passkeyError) {
+                    // Passkey failed, handle fallback based on mode
+                    debugLog$1(config, "triggerPasskeymeAuth", "Passkey authentication failed:", passkeyError);
+                    // Enhanced error handling for PasskeymeError
+                    if (passkeyError instanceof PasskeymeError) {
+                        debugLog$1(config, "triggerPasskeymeAuth", "PasskeymeError details:", {
+                            code: passkeyError.code,
+                            message: passkeyError.message,
+                            userMessage: passkeyError.userMessage,
+                            recoverable: passkeyError.recoverable,
+                            retryable: passkeyError.retryable,
+                            suggestedAction: passkeyError.suggestedAction,
+                        });
+                        // Handle specific error codes that should not trigger fallback
+                        if (passkeyError.code === PasskeymeErrorCode.USER_CANCELLED ||
+                            passkeyError.code === PasskeymeErrorCode.PASSKEY_CANCELLED) {
+                            // User cancelled - don't fallback, just call error handler
+                            if (onError) {
+                                onError(passkeyError.userMessage);
+                            }
+                            return;
+                        }
+                        if (passkeyError.code === PasskeymeErrorCode.PASSKEY_NOT_SUPPORTED) {
+                            // Passkeys not supported - immediately fallback without retrying
+                            debugLog$1(config, "triggerPasskeymeAuth", "Passkeys not supported, proceeding to fallback");
+                        }
+                    }
+                    debugLog$1(config, "triggerPasskeymeAuth", "Handling fallback for mode:", mode);
+                    if (mode === "hosted") {
+                        // Hosted mode: redirect to hosted auth pages
+                        debugLog$1(config, "triggerPasskeymeAuth", "Passkey failed, redirecting to hosted auth");
+                        auth.redirectToLogin();
+                        return;
+                    }
+                    else if (mode === "inline") {
+                        // Inline mode: provide OAuth providers to developer
+                        debugLog$1(config, "triggerPasskeymeAuth", "Passkey failed, providing OAuth options for inline mode");
+                        if (onOAuthRequired) {
+                            try {
+                                // Get available OAuth providers from app config
+                                const appConfig = await auth.getAppConfig();
+                                const providers = appConfig.oauthProviders || [
+                                    "google",
+                                    "github",
+                                ];
+                                debugLog$1(config, "triggerPasskeymeAuth", "Available OAuth providers:", providers);
+                                onOAuthRequired(providers);
+                                return;
+                            }
+                            catch (configError) {
+                                debugLog$1(config, "triggerPasskeymeAuth", "Failed to get app config, using default providers");
+                                onOAuthRequired(["google", "github"]);
+                                return;
+                            }
+                        }
+                        else {
+                            throw new Error("Passkey authentication failed and no onOAuthRequired callback provided for inline mode");
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error("[triggerPasskeymeAuth] Authentication error:", error);
+            let errorMessage = "Authentication failed";
+            // Enhanced error handling for PasskeymeError
+            if (error instanceof PasskeymeError) {
+                errorMessage = error.userMessage;
+                debugLog$1(config, "triggerPasskeymeAuth", "Final error handling:", {
+                    code: error.code,
+                    userMessage: error.userMessage,
+                    retryable: error.retryable,
+                    suggestedAction: error.suggestedAction,
+                });
+            }
+            else {
+                errorMessage = (error === null || error === void 0 ? void 0 : error.message) || "Authentication failed";
+            }
+            if (onError) {
+                onError(errorMessage);
+            }
+        }
+        finally {
+            setAuthLoading(false);
+        }
+    }, [auth, config, setAuthLoading]);
+    return {
+        user,
+        loading,
+        error,
+        isAuthenticated,
+        config,
+        redirectToLogin,
+        redirectToOAuth,
+        handleAuthCallback,
+        handleCallback,
+        handleTokenCallback,
+        logout,
+        getAccessToken,
+        refreshToken,
+        getBaseUrl,
+        getAppId,
+        isPasskeySupported,
+        hasStoredPasskeys,
+        passkeyLogin,
+        smartLogin,
+        getAppConfig,
+        triggerPasskeymeAuth,
+        authLoading,
+        auth,
+    };
+};
+
 const NotificationContext = createContext(null);
 const useNotifications = () => {
     const context = useContext(NotificationContext);
@@ -6039,7 +6379,7 @@ const PasskeymeCallbackHandler = ({ loadingComponent: LoadingComponent, errorCom
             updateState({ passkeyRegistering: true });
             // Create axios instance for PasskeyMe API
             const axiosInstance = axios$1.create({
-                baseURL: `${getBaseUrl()}/api/webauthn/${config.appId}`,
+                baseURL: `${getBaseUrl()}/webauthn/${config.appId}`,
                 headers: {
                     "x-api-key": effectivePasskeyConfig.apiKey,
                     "Content-Type": "application/json",
@@ -8730,5 +9070,5 @@ const useVirtualScrollList = (initialItems = [], itemHeight = 50, containerHeigh
     };
 };
 
-export { AnalyticsProvider, BundleOptimizer, DebugPanel, DevToolsDashboard, ImportAnalyzer, MockPasskeymeProvider, NotificationProvider, OptimizedStorage, PasskeymeAuthPanel, PasskeymeButton, PasskeymeCallbackHandler, PasskeymeErrorBoundary, PasskeymeErrorDisplay, PasskeymeErrorDisplayLazy, PasskeymeLoadingIndicator, PasskeymeLoadingIndicatorLazy, PasskeymeOAuthButton, PasskeymeProfiler, PasskeymeProtectedRoute, PasskeymeProvider, PasskeymeUserProfile, PerformanceDashboard as PerfDashboard, PerformanceDashboard$1 as PerformanceDashboard, PerformanceIndicator, PerformanceStats, RequestCache, SessionStorage, VirtualScrollList, accessibilityTestHelpers, buttonPresets, checkRuntimeDependencies, createLazyComponent, createMockConfig, createMockUser, createPerformanceTracker, createRenderWithPasskeymeProvider, createUsageTracker, devError, devWarn, e2eTestHelpers, enableHotReload, generateOptimizationReport, getButtonIconStyles, getEnhancedButtonStyles, getLoadingSpinnerStyles, initDevTools, logComponentTree, mockAuthResponses, performanceStore, performanceTestHelpers, requestCache, sessionStorage$1 as sessionStorage, storage, useAnalytics, useApiPerformanceMonitor, useAuth, useAuthState, useLoadingState, useMemoryMonitor, useNotifications, useOptimizedStorage, usePerformanceMonitor, usePerformanceStats, useRequestCache, useSessionStorage, useUsernameManager, useVirtualScrollList, validateProps, visualRegressionHelpers, withAuth, withDevTools, withErrorBoundary, withPerformanceProfiler, withProfiler };
+export { AnalyticsProvider, BundleOptimizer, DebugPanel, DevToolsDashboard, ImportAnalyzer, MockPasskeymeProvider, NotificationProvider, OptimizedStorage, PasskeymeAuthPanel, PasskeymeButton, PasskeymeCallbackHandler, PasskeymeErrorBoundary, PasskeymeErrorDisplay, PasskeymeErrorDisplayLazy, PasskeymeLoadingIndicator, PasskeymeLoadingIndicatorLazy, PasskeymeOAuthButton, PasskeymeProfiler, PasskeymeProtectedRoute, PasskeymeProvider, PasskeymeUserProfile, PerformanceDashboard as PerfDashboard, PerformanceDashboard$1 as PerformanceDashboard, PerformanceIndicator, PerformanceStats, RequestCache, SessionStorage, VirtualScrollList, accessibilityTestHelpers, buttonPresets, checkRuntimeDependencies, createLazyComponent, createMockConfig, createMockUser, createPerformanceTracker, createRenderWithPasskeymeProvider, createUsageTracker, devError, devWarn, e2eTestHelpers, enableHotReload, generateOptimizationReport, getButtonIconStyles, getEnhancedButtonStyles, getLoadingSpinnerStyles, initDevTools, logComponentTree, mockAuthResponses, performanceStore, performanceTestHelpers, requestCache, sessionStorage$1 as sessionStorage, storage, useAnalytics, useApiPerformanceMonitor, useAuth, useAuthState, useLoadingState, useMemoryMonitor, useNotifications, useOptimizedStorage, usePasskeyme, usePasskeymeContext, usePerformanceMonitor, usePerformanceStats, useRequestCache, useSessionStorage, useUsernameManager, useVirtualScrollList, validateProps, visualRegressionHelpers, withAuth, withDevTools, withErrorBoundary, withPerformanceProfiler, withProfiler };
 //# sourceMappingURL=index.esm.js.map