@passkeyme/auth 2.0.0 → 2.0.2

package/dist/index.umd.js

@@ -325,7 +325,7 @@
          * Get authentication configuration for the app
          */
         async getConfig() {
-            const backendConfig = await this.request(`${this.baseUrl}/api/auth/${this.appId}/config`);
+            const backendConfig = await this.request(`/api/auth/${this.appId}/config`);
             // Map backend response to SDK format
             return {
                 appId: backendConfig.app_id,
@@ -401,7 +401,7 @@
                 token: token,
                 app_id: this.appId,
             });
-            const response = (await this.request(`${this.baseUrl}/api/auth/verify-token?${params.toString()}`, {
+            const response = (await this.request(`/api/auth/verify-token?${params.toString()}`, {
                 method: "GET",
             }));
             if (!response.valid) {
@@ -455,6 +455,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 +804,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 +824,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,