@passkeyme/auth 2.0.1 → 2.0.3

package/dist/index.umd.js

@@ -269,10 +269,11 @@
             this.appId = appId;
             this.baseUrl = baseUrl.replace(/\/$/, ""); // Remove trailing slash
             this.debug = debug;
+            this.log("API Client initialized with baseUrl:", this.baseUrl);
         }
         log(...args) {
             if (this.debug) {
-                logger.debug("[PasskeymeAuth]", ...args);
+                logger.debug("[PasskeymeApiClient]", ...args);
             }
         }
         async request(endpoint, options = {}) {
@@ -455,6 +456,179 @@
         }
     }
 
+    /**
+     * Platform SDK Interface for Passkeyme
+     *
+     * This interface abstracts platform-specific passkey operations,
+     * allowing the core SDK to work across web, React Native, and other platforms.
+     */
+    /**
+     * No-op implementation for platforms without passkey support
+     */
+    class NoOpPasskeySDK {
+        async register(_options) {
+            return {
+                success: false,
+                error: "Passkeys not supported on this platform",
+            };
+        }
+        async authenticate(_options) {
+            return {
+                success: false,
+                error: "Passkeys not supported on this platform",
+            };
+        }
+        isSupported() {
+            return false;
+        }
+        canUseDiscoverableCredentials() {
+            return false;
+        }
+        supportsBiometrics() {
+            return false;
+        }
+    }
+
+    /**
+     * Web Platform SDK Implementation
+     *
+     * Wraps the passkeyme-web-sdk to implement the PasskeySDK interface
+     */
+    /**
+     * Web implementation of PasskeySDK using passkeyme-web-sdk
+     *
+     * This implementation should be used for web browsers that support WebAuthn.
+     * The actual passkeyme-web-sdk dependency should be provided by the consuming package.
+     */
+    class WebPasskeySDK {
+        constructor(webSDK) {
+            this.webSDK = webSDK;
+        }
+        async register(options) {
+            try {
+                if (!this.webSDK) {
+                    return {
+                        success: false,
+                        error: "Web SDK not available",
+                    };
+                }
+                // Extract the challenge from the options
+                // The options object contains: { username, displayName, challenge, ...otherChallengeData }
+                const { username, displayName, challenge, ...otherData } = options;
+                // Pass the challenge data directly to the web SDK
+                const challengeData = challenge || otherData;
+                // Call the web SDK register method with the challenge
+                const result = await this.webSDK.passkeyRegister(challengeData);
+                return {
+                    success: true,
+                    credentialId: result.credentialId || result.id,
+                    data: result,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error.message || "Registration failed",
+                };
+            }
+        }
+        async authenticate(options) {
+            try {
+                if (!this.webSDK) {
+                    return {
+                        success: false,
+                        error: "Web SDK not available",
+                    };
+                }
+                // Extract the challenge from the options
+                // The options object contains: { username, challenge, ...otherChallengeData }
+                const { username, challenge, ...otherData } = options;
+                // Pass the challenge data directly to the web SDK
+                const challengeData = challenge || otherData;
+                // Call the web SDK authenticate method with the challenge
+                const result = await this.webSDK.passkeyAuthenticate(challengeData);
+                return {
+                    success: true,
+                    assertion: result,
+                    data: result,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error.message || "Authentication failed",
+                };
+            }
+        }
+        isSupported() {
+            // Check if we're in a browser environment with WebAuthn support
+            return (typeof window !== "undefined" &&
+                typeof navigator !== "undefined" &&
+                "credentials" in navigator &&
+                typeof navigator.credentials.create === "function");
+        }
+        async getAvailableAuthenticators() {
+            // This is a basic implementation - the web SDK might provide more detailed info
+            const authenticators = [];
+            if (this.isSupported()) {
+                // Basic platform authenticator info
+                authenticators.push({
+                    type: "platform",
+                    supportsBiometrics: true, // Assume platform authenticators support biometrics
+                    supportsUserVerification: true,
+                });
+                // Basic cross-platform authenticator info
+                authenticators.push({
+                    type: "cross-platform",
+                    supportsBiometrics: false,
+                    supportsUserVerification: true,
+                });
+            }
+            return authenticators;
+        }
+        canUseDiscoverableCredentials() {
+            // Check if the platform supports discoverable credentials (resident keys)
+            return this.isSupported();
+        }
+        supportsBiometrics() {
+            // On web, this depends on the platform authenticator availability
+            // This is a simplified check - a more sophisticated implementation
+            // would actually test for platform authenticator support
+            return (this.isSupported() &&
+                typeof window !== "undefined" &&
+                /Mac|Win|Linux/.test(navigator.platform));
+        }
+        async initialize(config) {
+            // Initialize the web SDK if it has an init method
+            if (this.webSDK && typeof this.webSDK.init === "function") {
+                await this.webSDK.init(config);
+            }
+        }
+        async cleanup() {
+            // Cleanup if the web SDK has a cleanup method
+            if (this.webSDK && typeof this.webSDK.cleanup === "function") {
+                await this.webSDK.cleanup();
+            }
+        }
+    }
+
+    /**
+     * Platform SDK exports
+     */
+    // Conditionally export React Native SDK only in React Native environments
+    exports.ReactNativePasskeySDK = null;
+    try {
+        // Only try to load React Native SDK if we're actually in a React Native environment
+        if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+            const { ReactNativePasskeySDK: RNPasskeySDK, } = require("./ReactNativePasskeySDK");
+            exports.ReactNativePasskeySDK = RNPasskeySDK;
+        }
+    }
+    catch (error) {
+        // React Native SDK not available or not in React Native environment
+        exports.ReactNativePasskeySDK = null;
+    }
+
     /**
      * Browser storage implementation using localStorage or sessionStorage
      */
@@ -631,179 +805,6 @@
     TokenStorage.EXPIRES_AT_KEY = "passkeyme_expires_at";
     TokenStorage.TOKEN_TYPE_KEY = "passkeyme_token_type";
 
-    /**
-     * Platform SDK Interface for Passkeyme
-     *
-     * This interface abstracts platform-specific passkey operations,
-     * allowing the core SDK to work across web, React Native, and other platforms.
-     */
-    /**
-     * No-op implementation for platforms without passkey support
-     */
-    class NoOpPasskeySDK {
-        async register(_options) {
-            return {
-                success: false,
-                error: "Passkeys not supported on this platform",
-            };
-        }
-        async authenticate(_options) {
-            return {
-                success: false,
-                error: "Passkeys not supported on this platform",
-            };
-        }
-        isSupported() {
-            return false;
-        }
-        canUseDiscoverableCredentials() {
-            return false;
-        }
-        supportsBiometrics() {
-            return false;
-        }
-    }
-
-    /**
-     * Web Platform SDK Implementation
-     *
-     * Wraps the passkeyme-web-sdk to implement the PasskeySDK interface
-     */
-    /**
-     * Web implementation of PasskeySDK using passkeyme-web-sdk
-     *
-     * This implementation should be used for web browsers that support WebAuthn.
-     * The actual passkeyme-web-sdk dependency should be provided by the consuming package.
-     */
-    class WebPasskeySDK {
-        constructor(webSDK) {
-            this.webSDK = webSDK;
-        }
-        async register(options) {
-            try {
-                if (!this.webSDK) {
-                    return {
-                        success: false,
-                        error: "Web SDK not available",
-                    };
-                }
-                // Extract the challenge from the options
-                // The options object contains: { username, displayName, challenge, ...otherChallengeData }
-                const { username, displayName, challenge, ...otherData } = options;
-                // Pass the challenge data directly to the web SDK
-                const challengeData = challenge || otherData;
-                // Call the web SDK register method with the challenge
-                const result = await this.webSDK.passkeyRegister(challengeData);
-                return {
-                    success: true,
-                    credentialId: result.credentialId || result.id,
-                    data: result,
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: error.message || "Registration failed",
-                };
-            }
-        }
-        async authenticate(options) {
-            try {
-                if (!this.webSDK) {
-                    return {
-                        success: false,
-                        error: "Web SDK not available",
-                    };
-                }
-                // Extract the challenge from the options
-                // The options object contains: { username, challenge, ...otherChallengeData }
-                const { username, challenge, ...otherData } = options;
-                // Pass the challenge data directly to the web SDK
-                const challengeData = challenge || otherData;
-                // Call the web SDK authenticate method with the challenge
-                const result = await this.webSDK.passkeyAuthenticate(challengeData);
-                return {
-                    success: true,
-                    assertion: result,
-                    data: result,
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: error.message || "Authentication failed",
-                };
-            }
-        }
-        isSupported() {
-            // Check if we're in a browser environment with WebAuthn support
-            return (typeof window !== "undefined" &&
-                typeof navigator !== "undefined" &&
-                "credentials" in navigator &&
-                typeof navigator.credentials.create === "function");
-        }
-        async getAvailableAuthenticators() {
-            // This is a basic implementation - the web SDK might provide more detailed info
-            const authenticators = [];
-            if (this.isSupported()) {
-                // Basic platform authenticator info
-                authenticators.push({
-                    type: "platform",
-                    supportsBiometrics: true, // Assume platform authenticators support biometrics
-                    supportsUserVerification: true,
-                });
-                // Basic cross-platform authenticator info
-                authenticators.push({
-                    type: "cross-platform",
-                    supportsBiometrics: false,
-                    supportsUserVerification: true,
-                });
-            }
-            return authenticators;
-        }
-        canUseDiscoverableCredentials() {
-            // Check if the platform supports discoverable credentials (resident keys)
-            return this.isSupported();
-        }
-        supportsBiometrics() {
-            // On web, this depends on the platform authenticator availability
-            // This is a simplified check - a more sophisticated implementation
-            // would actually test for platform authenticator support
-            return (this.isSupported() &&
-                typeof window !== "undefined" &&
-                /Mac|Win|Linux/.test(navigator.platform));
-        }
-        async initialize(config) {
-            // Initialize the web SDK if it has an init method
-            if (this.webSDK && typeof this.webSDK.init === "function") {
-                await this.webSDK.init(config);
-            }
-        }
-        async cleanup() {
-            // Cleanup if the web SDK has a cleanup method
-            if (this.webSDK && typeof this.webSDK.cleanup === "function") {
-                await this.webSDK.cleanup();
-            }
-        }
-    }
-
-    /**
-     * Platform SDK exports
-     */
-    // Conditionally export React Native SDK only in React Native environments
-    exports.ReactNativePasskeySDK = null;
-    try {
-        // Only try to load React Native SDK if we're actually in a React Native environment
-        if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-            const { ReactNativePasskeySDK: RNPasskeySDK, } = require("./ReactNativePasskeySDK");
-            exports.ReactNativePasskeySDK = RNPasskeySDK;
-        }
-    }
-    catch (error) {
-        // React Native SDK not available or not in React Native environment
-        exports.ReactNativePasskeySDK = null;
-    }
-
     /**
      * Main Passkeyme Authentication SDK class
      */
@@ -824,7 +825,7 @@
                 ? `${window.location.origin}/auth/callback`
                 : "http://localhost:3000/auth/callback";
             // Support both baseUrl and apiUrl for flexibility
-            const serverUrl = config.apiUrl || config.baseUrl || "https://auth.passkeyme.com";
+            const serverUrl = config.baseUrl || "https://auth.passkeyme.com";
             this.config = {
                 appId: config.appId,
                 baseUrl: serverUrl,
@@ -845,6 +846,7 @@
                 logger.enableDebug();
                 logger.debug("[DEBUG] Logger debug mode enabled, testing logger...");
                 logger.debug("[DEBUG] Logger config after enableDebug:", logger.getConfig());
+                logger.debug("config.baseUrl:", this.config.baseUrl);
                 logger.debug("Logger test message - if you see this, logger is working");
             }
             logger.debug("Initialized with config:", this.config);