@glideidentity/web-client-sdk 5.1.3 → 6.0.0-beta.1

package/dist/esm/adapters/index.js

@@ -0,0 +1,11 @@
+/**
+ * Framework adapters for Phone Authentication SDK.
+ *
+ * Import from specific adapter paths for proper tree-shaking:
+ * - @glideidentity/web-client-sdk/react
+ * - @glideidentity/web-client-sdk/vue
+ * - @glideidentity/web-client-sdk/vanilla
+ */
+// Note: Don't import React/Vue here to avoid bundling framework deps
+// Each adapter should be imported directly from its path
+export { PhoneAuthClient } from '../client/phone-auth-client';

package/dist/esm/adapters/react.js

@@ -0,0 +1,182 @@
+/**
+ * React Adapter for Phone Authentication SDK.
+ *
+ * Provides a React hook that wraps PhoneAuthClient with React state management.
+ *
+ * @example
+ * ```tsx
+ * import { usePhoneAuth } from '@glideidentity/web-client-sdk/react';
+ *
+ * function AuthButton() {
+ *   const { authenticate, isLoading, error, result } = usePhoneAuth({ debug: true });
+ *
+ *   const handleClick = async () => {
+ *     try {
+ *       const result = await authenticate({
+ *         use_case: 'VerifyPhoneNumber',
+ *         phone_number: '+14155551234'
+ *       });
+ *       console.log('Verified:', result.verified);
+ *     } catch (err) {
+ *       // Error is also in `error` state
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={isLoading}>
+ *       {isLoading ? 'Verifying...' : 'Verify Phone'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+import { useState, useCallback, useMemo } from 'react';
+import { PhoneAuthClient } from '../client/phone-auth-client';
+// Re-export PhoneAuthClient and core types/constants for convenience
+export { PhoneAuthClient } from '../client/phone-auth-client';
+export { USE_CASE, AUTHENTICATION_STRATEGY } from '../core/types';
+export { ERROR_CODES, isAuthError, createAuthError } from '../core/errors';
+// ============================================================================
+// HOOK
+// ============================================================================
+/**
+ * React hook for phone authentication.
+ */
+export function usePhoneAuth(config) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [result, setResult] = useState(null);
+    const [step, setStep] = useState('idle');
+    // Memoize client - recreate if config changes
+    // Using JSON.stringify for stable comparison of config object
+    const configKey = JSON.stringify(config);
+    const client = useMemo(() => new PhoneAuthClient(config), [configKey]);
+    const isSupported = useMemo(() => client.isSupported(), [client]);
+    /**
+     * High-level authentication.
+     */
+    const authenticate = useCallback(async (request, options) => {
+        setIsLoading(true);
+        setError(null);
+        setStep('preparing');
+        try {
+            const authResult = await client.authenticate(request, options);
+            setResult(authResult);
+            setStep('complete');
+            return authResult;
+        }
+        catch (err) {
+            const authError = err;
+            setError(authError);
+            setStep('error');
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    /**
+     * Granular: Prepare.
+     */
+    const prepare = useCallback(async (request) => {
+        setIsLoading(true);
+        setError(null);
+        setStep('preparing');
+        try {
+            const result = await client.prepare(request);
+            setStep('idle'); // Reset step on success (prepare is just first step)
+            return result;
+        }
+        catch (err) {
+            const authError = err;
+            setError(authError);
+            setStep('error');
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    /**
+     * Granular: Invoke.
+     */
+    const invokeSecurePrompt = useCallback(async (prepared, options) => {
+        setStep('invoking');
+        try {
+            return await client.invokeSecurePrompt(prepared, options);
+        }
+        catch (err) {
+            const authError = err;
+            setError(authError);
+            setStep('error');
+            throw err;
+        }
+    }, [client]);
+    /**
+     * Granular: Get phone number.
+     */
+    const getPhoneNumber = useCallback(async (credential, session) => {
+        setIsLoading(true);
+        setStep('processing');
+        try {
+            const authResult = await client.getPhoneNumber(credential, session);
+            setResult(authResult);
+            setStep('complete');
+            return authResult;
+        }
+        catch (err) {
+            const authError = err;
+            setError(authError);
+            setStep('error');
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    /**
+     * Granular: Verify phone number.
+     */
+    const verifyPhoneNumber = useCallback(async (credential, session) => {
+        setIsLoading(true);
+        setStep('processing');
+        try {
+            const authResult = await client.verifyPhoneNumber(credential, session);
+            setResult(authResult);
+            setStep('complete');
+            return authResult;
+        }
+        catch (err) {
+            const authError = err;
+            setError(authError);
+            setStep('error');
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client]);
+    /**
+     * Reset state.
+     */
+    const reset = useCallback(() => {
+        setIsLoading(false);
+        setError(null);
+        setResult(null);
+        setStep('idle');
+    }, []);
+    return {
+        isLoading,
+        error,
+        result,
+        step,
+        isSupported,
+        authenticate,
+        prepare,
+        invokeSecurePrompt,
+        getPhoneNumber,
+        verifyPhoneNumber,
+        reset,
+        client,
+    };
+}

package/dist/esm/adapters/vanilla.js

@@ -0,0 +1,29 @@
+/**
+ * Vanilla JavaScript Adapter for Phone Authentication SDK.
+ *
+ * Simply re-exports the PhoneAuthClient for use without a framework.
+ *
+ * @example
+ * ```javascript
+ * import { PhoneAuthClient } from '@glideidentity/web-client-sdk/vanilla';
+ *
+ * const client = new PhoneAuthClient({ debug: true });
+ *
+ * document.getElementById('auth-btn').addEventListener('click', async () => {
+ *   try {
+ *     const result = await client.authenticate({
+ *       use_case: 'VerifyPhoneNumber',
+ *       phone_number: '+14155551234'
+ *     });
+ *     console.log('Verified:', result.verified);
+ *   } catch (error) {
+ *     console.error('Auth failed:', error);
+ *   }
+ * });
+ * ```
+ */
+// Re-export everything from client
+export { PhoneAuthClient } from '../client/phone-auth-client';
+// Re-export constants
+export { USE_CASE, AUTHENTICATION_STRATEGY } from '../core/types';
+export { ERROR_CODES, isAuthError, createAuthError } from '../core/errors';

package/dist/esm/adapters/vue.js

@@ -0,0 +1,177 @@
+/**
+ * Vue Adapter for Phone Authentication SDK.
+ *
+ * Provides a Vue composable that wraps PhoneAuthClient with Vue reactivity.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { usePhoneAuth } from '@glideidentity/web-client-sdk/vue';
+ *
+ * const { authenticate, isLoading, error, result } = usePhoneAuth({ debug: true });
+ *
+ * const handleClick = async () => {
+ *   try {
+ *     const result = await authenticate({
+ *       use_case: 'VerifyPhoneNumber',
+ *       phone_number: '+14155551234'
+ *     });
+ *     console.log('Verified:', result.verified);
+ *   } catch (err) {
+ *     // Error is also in `error` ref
+ *   }
+ * };
+ * </script>
+ *
+ * <template>
+ *   <button @click="handleClick" :disabled="isLoading">
+ *     {{ isLoading ? 'Verifying...' : 'Verify Phone' }}
+ *   </button>
+ * </template>
+ * ```
+ */
+import { ref, computed } from 'vue';
+import { PhoneAuthClient } from '../client/phone-auth-client';
+// Re-export PhoneAuthClient and core types/constants for convenience
+export { PhoneAuthClient } from '../client/phone-auth-client';
+export { USE_CASE, AUTHENTICATION_STRATEGY } from '../core/types';
+export { ERROR_CODES, isAuthError, createAuthError } from '../core/errors';
+// ============================================================================
+// COMPOSABLE
+// ============================================================================
+/**
+ * Vue composable for phone authentication.
+ */
+export function usePhoneAuth(config) {
+    // Create client once
+    const client = new PhoneAuthClient(config);
+    // Reactive state
+    const isLoading = ref(false);
+    const error = ref(null);
+    const result = ref(null);
+    const step = ref('idle');
+    // Computed
+    const isSupported = computed(() => client.isSupported());
+    /**
+     * High-level authentication.
+     */
+    async function authenticate(request, options) {
+        isLoading.value = true;
+        error.value = null;
+        step.value = 'preparing';
+        try {
+            const authResult = await client.authenticate(request, options);
+            result.value = authResult;
+            step.value = 'complete';
+            return authResult;
+        }
+        catch (err) {
+            error.value = err;
+            step.value = 'error';
+            throw err;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    }
+    /**
+     * Granular: Prepare.
+     */
+    async function prepare(request) {
+        isLoading.value = true;
+        error.value = null;
+        step.value = 'preparing';
+        try {
+            const result = await client.prepare(request);
+            step.value = 'idle'; // Reset step on success (prepare is just first step)
+            return result;
+        }
+        catch (err) {
+            error.value = err;
+            step.value = 'error';
+            throw err;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    }
+    /**
+     * Granular: Invoke.
+     */
+    async function invokeSecurePrompt(prepared, options) {
+        step.value = 'invoking';
+        try {
+            return await client.invokeSecurePrompt(prepared, options);
+        }
+        catch (err) {
+            error.value = err;
+            step.value = 'error';
+            throw err;
+        }
+    }
+    /**
+     * Granular: Get phone number.
+     */
+    async function getPhoneNumber(credential, session) {
+        isLoading.value = true;
+        step.value = 'processing';
+        try {
+            const authResult = await client.getPhoneNumber(credential, session);
+            result.value = authResult;
+            step.value = 'complete';
+            return authResult;
+        }
+        catch (err) {
+            error.value = err;
+            step.value = 'error';
+            throw err;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    }
+    /**
+     * Granular: Verify phone number.
+     */
+    async function verifyPhoneNumber(credential, session) {
+        isLoading.value = true;
+        step.value = 'processing';
+        try {
+            const authResult = await client.verifyPhoneNumber(credential, session);
+            result.value = authResult;
+            step.value = 'complete';
+            return authResult;
+        }
+        catch (err) {
+            error.value = err;
+            step.value = 'error';
+            throw err;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    }
+    /**
+     * Reset state.
+     */
+    function reset() {
+        isLoading.value = false;
+        error.value = null;
+        result.value = null;
+        step.value = 'idle';
+    }
+    return {
+        isLoading,
+        error,
+        result,
+        step,
+        isSupported,
+        authenticate,
+        prepare,
+        invokeSecurePrompt,
+        getPhoneNumber,
+        verifyPhoneNumber,
+        reset,
+        client,
+    };
+}

package/dist/esm/browser.js

@@ -1,11 +1,30 @@
-// Browser-specific entry point for vanilla JavaScript usage
-// This excludes framework-specific adapters that require Angular/React/Vue
-// Phone Authentication - Core client
-export { PhoneAuthClient } from './core/phone-auth';
-// Phone Auth Error Utilities
-export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './core/phone-auth';
-// Export constants for use case and strategy
-export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from './core/phone-auth/types';
-// Vanilla adapters ONLY (no framework dependencies)
-export { VanillaClient as ClientManager } from './adapters/vanilla/client';
-export { PhoneAuthManager } from './adapters/vanilla/phone-auth';
+/**
+ * Browser-specific entry point for vanilla JavaScript usage.
+ * This is bundled via webpack and exposed as `window.GlideWebClientSDK`.
+ *
+ * @example
+ * ```html
+ * <script src="/sdk/web-client-sdk.min.js"></script>
+ * <script>
+ *   const client = new GlideWebClientSDK.PhoneAuthClient({ debug: true });
+ *   const result = await client.authenticate({
+ *     use_case: GlideWebClientSDK.USE_CASE.VERIFY_PHONE_NUMBER,
+ *     phone_number: '+14155551234'
+ *   });
+ * </script>
+ * ```
+ */
+// Main client
+export { PhoneAuthClient } from './client/phone-auth-client';
+// Constants
+export { USE_CASE, AUTHENTICATION_STRATEGY } from './core/types';
+// Error codes
+export { ERROR_CODES } from './core/errors';
+// Type guards
+export { isInvokeResult, isAuthCredential, isTS43Strategy, isLinkStrategy, isDesktopStrategy, isCancellable, isTS43Data, isLinkData, isDesktopData, isGetPhoneNumberResponse, isVerifyPhoneNumberResponse, isErrorResponse, } from './core/type-guards';
+// Error utilities
+export { isAuthError, isClientError, isRetryableError, getUserMessage, createAuthError, } from './core/errors';
+// Validators
+export { validatePhoneNumber, validatePlmn, } from './core/validators';
+// UI components
+export { AuthModal, createQRCodeDataFromDesktop } from './ui/modal';

package/dist/esm/client/http.js

@@ -0,0 +1,156 @@
+/**
+ * HTTP Client for Phone Authentication SDK.
+ *
+ * Provides a default fetch-based implementation with:
+ * - Timeout support
+ * - Static and dynamic headers
+ * - Error parsing using Core utilities
+ */
+import { createAuthError, parseBackendError, ERROR_CODES } from '../core/errors';
+// ============================================================================
+// DEFAULT HTTP CLIENT
+// ============================================================================
+/**
+ * Create a default fetch-based HTTP client.
+ *
+ * @example
+ * ```typescript
+ * const http = createHttpClient({
+ *   timeout: 30000,
+ *   headers: {
+ *     common: { 'X-Client-Version': '2.0.0' },
+ *     prepare: { 'X-Prepare-Only': 'true' }
+ *   },
+ *   dynamicHeaders: async (ctx) => {
+ *     const token = await getAuthToken();
+ *     return { 'Authorization': `Bearer ${token}` };
+ *   }
+ * });
+ * ```
+ */
+export function createHttpClient(config = {}) {
+    const { timeout = 30000, headers = {}, dynamicHeaders } = config;
+    /**
+     * Build headers for a request.
+     */
+    async function buildHeaders(context, additionalHeaders) {
+        const result = {
+            'Content-Type': 'application/json',
+        };
+        // Add common headers
+        if (headers.common) {
+            Object.assign(result, headers.common);
+        }
+        // Add endpoint-specific headers
+        const endpointHeaders = headers[context.endpoint];
+        if (endpointHeaders && typeof endpointHeaders === 'object') {
+            Object.assign(result, endpointHeaders);
+        }
+        // Add dynamic headers
+        if (dynamicHeaders) {
+            const dynamic = await dynamicHeaders(context);
+            Object.assign(result, dynamic);
+        }
+        // Add additional headers from options
+        if (additionalHeaders) {
+            Object.assign(result, additionalHeaders);
+        }
+        return result;
+    }
+    /**
+     * Make a fetch request with timeout.
+     */
+    async function fetchWithTimeout(url, init, requestTimeout, signal) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+        // If external signal provided, link it to our controller
+        // Store handler reference so we can remove it later (prevent memory leak)
+        const abortHandler = signal ? () => controller.abort() : null;
+        if (signal && abortHandler) {
+            signal.addEventListener('abort', abortHandler);
+        }
+        try {
+            const response = await fetch(url, {
+                ...init,
+                signal: controller.signal,
+            });
+            return response;
+        }
+        catch (error) {
+            // Check if it's a timeout (AbortError from our controller)
+            if (error instanceof Error && error.name === 'AbortError') {
+                // Check if it was our timeout or external abort
+                if (signal?.aborted) {
+                    throw createAuthError(ERROR_CODES.CANCELLED, 'Request was cancelled');
+                }
+                throw createAuthError(ERROR_CODES.TIMEOUT, 'Request timed out');
+            }
+            // Network error
+            throw createAuthError(ERROR_CODES.NETWORK_ERROR, error instanceof Error ? error.message : 'Network request failed');
+        }
+        finally {
+            clearTimeout(timeoutId);
+            // Clean up event listener to prevent memory leak
+            if (signal && abortHandler) {
+                signal.removeEventListener('abort', abortHandler);
+            }
+        }
+    }
+    /**
+     * Parse response and handle errors.
+     */
+    async function parseResponse(response) {
+        // Try to parse JSON
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch {
+            // If JSON parsing fails and response is not ok, throw generic error
+            if (!response.ok) {
+                throw createAuthError(ERROR_CODES.INVALID_RESPONSE, `Request failed with status ${response.status}`);
+            }
+            throw createAuthError(ERROR_CODES.INVALID_RESPONSE, 'Failed to parse response');
+        }
+        // If response is not ok, parse as error
+        if (!response.ok) {
+            throw parseBackendError({ ...data, status: response.status });
+        }
+        return data;
+    }
+    /**
+     * Determine endpoint type from URL for header context.
+     */
+    function getEndpointType(url) {
+        if (url.includes('/prepare'))
+            return 'prepare';
+        if (url.includes('/process') || url.includes('/get-phone') || url.includes('/verify-phone'))
+            return 'process';
+        if (url.includes('/status'))
+            return 'polling';
+        return 'prepare'; // Default
+    }
+    return {
+        async post(url, body, options) {
+            const endpointType = getEndpointType(url);
+            const requestHeaders = await buildHeaders({ endpoint: endpointType, method: 'POST' }, options?.headers);
+            const response = await fetchWithTimeout(url, {
+                method: 'POST',
+                headers: requestHeaders,
+                body: JSON.stringify(body),
+            }, options?.timeout || timeout, options?.signal);
+            return parseResponse(response);
+        },
+        async get(url, options) {
+            const endpointType = getEndpointType(url);
+            const requestHeaders = await buildHeaders({ endpoint: endpointType, method: 'GET' }, options?.headers);
+            // Remove Content-Type for GET requests
+            delete requestHeaders['Content-Type'];
+            const response = await fetchWithTimeout(url, {
+                method: 'GET',
+                headers: requestHeaders,
+            }, options?.timeout || timeout, options?.signal);
+            return parseResponse(response);
+        },
+    };
+}

package/dist/esm/client/index.js

@@ -0,0 +1,11 @@
+/**
+ * Client module exports.
+ */
+// Main Client
+export { PhoneAuthClient } from './phone-auth-client';
+// HTTP Client
+export { createHttpClient } from './http';
+// Logger
+export { createLogger, createNoopLogger } from './logger';
+// Strategies (internal, but exported for advanced use)
+export { createPollingHandler } from './strategies/polling';