@glideidentity/web-client-sdk 5.0.0 → 5.0.1

package/dist/esm/core/phone-auth/error-utils.d.ts

@@ -65,43 +65,14 @@ export declare const PhoneAuthErrorCode: {
 };
 export type PhoneAuthErrorCode = typeof PhoneAuthErrorCode[keyof typeof PhoneAuthErrorCode];
 import type { AuthError } from './types';
-/**
- * Type guard to check if an error is a PhoneAuthError
- */
 export declare function isPhoneAuthError(error: any): error is AuthError;
-/**
- * Check if error should be shown to user
- */
 export declare function isUserError(error: AuthError): boolean;
-/**
- * Get user-friendly error message
- */
 export declare function getUserMessage(error: AuthError): string;
-/**
- * Check if error matches a specific code
- */
 export declare function isErrorCode(error: AuthError, code: PhoneAuthErrorCode): boolean;
-/**
- * Get retry delay for rate-limited requests
- */
 export declare function getRetryDelay(error: AuthError): number | null;
-/**
- * Check if error is retryable
- */
 export declare function isRetryableError(error: AuthError): boolean;
-/**
- * Parse error response from backend API
- */
 export declare function parseBackendError(response: any): AuthError;
-/**
- * Serialize error for logging/observability tools like Sentry
- * This ensures all error details are captured in a format that can be sent over the network
- */
 export declare function serializeError(error: AuthError): Record<string, any>;
-/**
- * Create a breadcrumb trail for error tracking
- * Useful for understanding the sequence of events leading to an error
- */
 export declare function createErrorBreadcrumb(error: AuthError): {
     category: string;
     message: string;

package/dist/esm/core/phone-auth/error-utils.js

@@ -1,36 +1,29 @@
 import { SDK_VERSION } from '../version';
-// Error constants matching the backend for consistency
 export const PhoneAuthErrorCode = {
-    // 400 Bad Request errors
     BAD_REQUEST: 'BAD_REQUEST',
     VALIDATION_ERROR: 'VALIDATION_ERROR',
     INVALID_PARAMETERS: 'INVALID_PARAMETERS',
     MISSING_PARAMETERS: 'MISSING_PARAMETERS',
     INVALID_PHONE_NUMBER: 'INVALID_PHONE_NUMBER',
     INVALID_MCC_MNC: 'INVALID_MCC_MNC',
-    // 401 Unauthorized errors
     UNAUTHORIZED: 'UNAUTHORIZED',
     INVALID_CREDENTIALS: 'INVALID_CREDENTIALS',
     EXPIRED_TOKEN: 'EXPIRED_TOKEN',
     TOKEN_ACQUISITION_FAILED: 'TOKEN_ACQUISITION_FAILED',
     INVALID_API_KEY: 'INVALID_API_KEY',
     MISSING_AUTH_HEADER: 'MISSING_AUTH_HEADER',
-    // 403 Forbidden errors
     FORBIDDEN: 'FORBIDDEN',
     INSUFFICIENT_PERMISSIONS: 'INSUFFICIENT_PERMISSIONS',
     ACCESS_DENIED: 'ACCESS_DENIED',
-    // 404 Not Found errors
     NOT_FOUND: 'NOT_FOUND',
     RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
     SESSION_NOT_FOUND: 'SESSION_NOT_FOUND',
     CARRIER_NOT_FOUND: 'CARRIER_NOT_FOUND',
     ENDPOINT_NOT_FOUND: 'ENDPOINT_NOT_FOUND',
-    // 409 Conflict errors
     CONFLICT: 'CONFLICT',
     RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
     DUPLICATE_SESSION: 'DUPLICATE_SESSION',
     CONCURRENT_MODIFICATION: 'CONCURRENT_MODIFICATION',
-    // 422 Unprocessable Entity errors
     UNPROCESSABLE_ENTITY: 'UNPROCESSABLE_ENTITY',
     UNSUPPORTED_VERIFICATION: 'UNSUPPORTED_VERIFICATION',
     INVALID_VERIFICATION: 'INVALID_VERIFICATION',
@@ -46,160 +39,117 @@ export const PhoneAuthErrorCode = {
     INVALID_SESSION_STATE: 'INVALID_SESSION_STATE',
     PHONE_NUMBER_MISMATCH: 'PHONE_NUMBER_MISMATCH',
     INVALID_CREDENTIAL_FORMAT: 'INVALID_CREDENTIAL_FORMAT',
-    // 429 Too Many Requests errors
     RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
     TOO_MANY_REQUESTS: 'TOO_MANY_REQUESTS',
     QUOTA_EXCEEDED: 'QUOTA_EXCEEDED',
-    // 500 Internal Server errors
     INTERNAL_SERVER_ERROR: 'INTERNAL_SERVER_ERROR',
     CIRCUIT_BREAKER_CONFIGURATION_ERROR: 'CIRCUIT_BREAKER_CONFIGURATION_ERROR',
     DATABASE_ERROR: 'DATABASE_ERROR',
     CACHE_ERROR: 'CACHE_ERROR',
     SERIALIZATION_ERROR: 'SERIALIZATION_ERROR',
     CRYPTO_ERROR: 'CRYPTO_ERROR',
-    // 502 Bad Gateway errors
     BAD_GATEWAY: 'BAD_GATEWAY',
     UPSTREAM_ERROR: 'UPSTREAM_ERROR',
     INVALID_RESPONSE: 'INVALID_RESPONSE',
-    // 503 Service Unavailable errors
     SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
     DOWNSTREAM_SERVICE_ERROR: 'DOWNSTREAM_SERVICE_ERROR',
     PROVIDER_ERROR: 'PROVIDER_ERROR',
     CIRCUIT_BREAKER_OPEN: 'CIRCUIT_BREAKER_OPEN',
     MAINTENANCE_MODE: 'MAINTENANCE_MODE',
-    // 504 Gateway Timeout errors
     GATEWAY_TIMEOUT: 'GATEWAY_TIMEOUT',
     REQUEST_TIMEOUT: 'REQUEST_TIMEOUT',
     UPSTREAM_TIMEOUT: 'UPSTREAM_TIMEOUT',
     DEADLINE_EXCEEDED: 'DEADLINE_EXCEEDED',
-    // Browser-specific errors (never thrown by backend)
     BROWSER_NOT_SUPPORTED: 'BROWSER_NOT_SUPPORTED',
     USER_DENIED: 'USER_DENIED',
     NETWORK_ERROR: 'NETWORK_ERROR',
 };
-// User-facing error messages - NEVER expose carrier names or phone numbers
 const USER_ERROR_MESSAGES = {
-    // Privacy-conscious messages - no carrier/phone info exposed
     CARRIER_NOT_ELIGIBLE: 'Your carrier is not eligible for this verification method.',
     CARRIER_IDENTIFICATION_FAILED: 'Unable to identify carrier for the provided phone number.',
     CARRIER_NOT_FOUND: 'Carrier information not available.',
     UNSUPPORTED_CARRIER: 'This carrier is not supported.',
-    // Rate limiting
     RATE_LIMIT_EXCEEDED: 'Too many attempts. Please wait a moment and try again.',
     TOO_MANY_REQUESTS: 'Too many requests. Please slow down and try again.',
     QUOTA_EXCEEDED: 'Usage limit reached. Please try again later.',
-    // Session errors
     SESSION_NOT_FOUND: 'Your session has expired. Please start over.',
     INVALID_SESSION_STATE: 'Invalid session state. Please start over.',
     DUPLICATE_SESSION: 'A session already exists. Please complete or cancel it first.',
-    // Browser/platform errors
     BROWSER_NOT_SUPPORTED: 'Digital Credentials API is not available. Please enable the #web-identity-digital-credentials flag in chrome://flags',
     UNSUPPORTED_PLATFORM: 'This platform is not supported for authentication.',
     UNSUPPORTED_STRATEGY: 'This authentication method is not available.',
     USER_DENIED: 'Authentication was cancelled. Please try again when you\'re ready.',
-    // Service availability
     SERVICE_UNAVAILABLE: 'The service is temporarily unavailable. Please try again later.',
     CIRCUIT_BREAKER_OPEN: 'Service is experiencing issues. Please try again later.',
     MAINTENANCE_MODE: 'Service is under maintenance. Please try again later.',
     DOWNSTREAM_SERVICE_ERROR: 'A required service is unavailable. Please try again later.',
-    // Authentication errors
     TOKEN_ACQUISITION_FAILED: 'Failed to acquire authentication token. Please try again.',
     EXPIRED_TOKEN: 'Your authentication has expired. Please start over.',
     INVALID_CREDENTIALS: 'Invalid credentials provided.',
-    // Validation errors
     INVALID_PHONE_NUMBER: 'Please enter a valid phone number.',
     PHONE_NUMBER_MISMATCH: 'Phone number mismatch. Please verify your number.',
     INVALID_PARAMETERS: 'Invalid parameters provided.',
     MISSING_PARAMETERS: 'Required information is missing.',
     VALIDATION_ERROR: 'Validation failed. Please check your input.',
-    // Network errors
     NETWORK_ERROR: 'Network connection failed. Please check your connection and try again.',
     GATEWAY_TIMEOUT: 'Request timed out. Please try again.',
     REQUEST_TIMEOUT: 'Request timed out. Please try again.',
     DEADLINE_EXCEEDED: 'Operation took too long. Please try again.',
-    // Verification errors
     VERIFICATION_FAILED: 'Verification failed. Please try again.',
     INVALID_VERIFICATION: 'Invalid verification response.',
     INVALID_CREDENTIAL_FORMAT: 'Invalid credential format.',
-    // Generic fallbacks
     BAD_REQUEST: 'Invalid request. Please try again.',
     UNAUTHORIZED: 'Authentication required.',
     FORBIDDEN: 'Access denied.',
     NOT_FOUND: 'Resource not found.',
     INTERNAL_SERVER_ERROR: 'An error occurred. Please try again later.',
 };
-// Errors that should be shown to users vs logged internally
 const USER_FACING_ERRORS = new Set([
-    // Carrier errors (privacy-safe messages)
     'CARRIER_NOT_ELIGIBLE',
     'CARRIER_IDENTIFICATION_FAILED',
     'CARRIER_NOT_FOUND',
     'UNSUPPORTED_CARRIER',
-    // Rate limiting
     'RATE_LIMIT_EXCEEDED',
     'TOO_MANY_REQUESTS',
     'QUOTA_EXCEEDED',
-    // Browser/platform
     'BROWSER_NOT_SUPPORTED',
     'UNSUPPORTED_PLATFORM',
     'UNSUPPORTED_STRATEGY',
     'USER_DENIED',
-    // Session
     'SESSION_NOT_FOUND',
     'INVALID_SESSION_STATE',
     'EXPIRED_TOKEN',
-    // Service availability
     'SERVICE_UNAVAILABLE',
     'CIRCUIT_BREAKER_OPEN',
     'MAINTENANCE_MODE',
-    // Network
     'NETWORK_ERROR',
     'GATEWAY_TIMEOUT',
     'REQUEST_TIMEOUT',
-    // Validation
     'INVALID_PHONE_NUMBER',
     'PHONE_NUMBER_MISMATCH',
     'MISSING_PARAMETERS',
     'VALIDATION_ERROR',
 ]);
-/**
- * Type guard to check if an error is a PhoneAuthError
- */
 export function isPhoneAuthError(error) {
     return error &&
         typeof error.code === 'string' &&
         typeof error.message === 'string';
 }
-/**
- * Check if error should be shown to user
- */
 export function isUserError(error) {
     return USER_FACING_ERRORS.has(error.code);
 }
-/**
- * Get user-friendly error message
- */
 export function getUserMessage(error) {
     return USER_ERROR_MESSAGES[error.code] || 'An unexpected error occurred. Please try again.';
 }
-/**
- * Check if error matches a specific code
- */
 export function isErrorCode(error, code) {
     return error.code === code;
 }
-/**
- * Get retry delay for rate-limited requests
- */
 export function getRetryDelay(error) {
     if (error.code === PhoneAuthErrorCode.RATE_LIMIT_EXCEEDED && error.retryAfter) {
-        return error.retryAfter * 1000; // Convert to milliseconds
+        return error.retryAfter * 1000;
     }
     return null;
 }
-/**
- * Check if error is retryable
- */
 export function isRetryableError(error) {
     const retryableCodes = [
         PhoneAuthErrorCode.NETWORK_ERROR,
@@ -209,12 +159,8 @@ export function isRetryableError(error) {
     ];
     return retryableCodes.includes(error.code);
 }
-/**
- * Parse error response from backend API
- */
 export function parseBackendError(response) {
     var _a, _b;
-    // Direct error structure from backend
     if (response && typeof response === 'object' && (response.code || response.error)) {
         const errorCode = response.code || response.error;
         const error = {
@@ -224,18 +170,15 @@ export function parseBackendError(response) {
             requestId: response.requestId || response.request_id,
             timestamp: response.timestamp,
             details: response.details,
-            // Include trace info for observability
             traceId: response.trace_id || response.traceId,
             spanId: response.span_id || response.spanId,
             service: response.service
         };
-        // Extract retryAfter from details if present
         if ((_a = response.details) === null || _a === void 0 ? void 0 : _a.retryAfter) {
             error.retryAfter = response.details.retryAfter;
         }
         return error;
     }
-    // Handle HTTP response with error
     if (response && response.status) {
         const code = mapStatusToErrorCode(response.status);
         return {
@@ -245,16 +188,12 @@ export function parseBackendError(response) {
             requestId: (_b = response.headers) === null || _b === void 0 ? void 0 : _b['x-request-id']
         };
     }
-    // Default to unexpected error
     return {
         code: PhoneAuthErrorCode.INTERNAL_SERVER_ERROR,
         message: 'An unexpected error occurred',
         status: 500
     };
 }
-/**
- * Map HTTP status to error code
- */
 function mapStatusToErrorCode(status) {
     switch (status) {
         case 400: return PhoneAuthErrorCode.BAD_REQUEST;
@@ -271,56 +210,35 @@ function mapStatusToErrorCode(status) {
         default: return PhoneAuthErrorCode.INTERNAL_SERVER_ERROR;
     }
 }
-/**
- * Serialize error for logging/observability tools like Sentry
- * This ensures all error details are captured in a format that can be sent over the network
- */
 export function serializeError(error) {
     return {
-        // Core error info
         code: error.code,
         message: error.message,
-        // Backend error details
         status: error.status,
         requestId: error.requestId,
         timestamp: error.timestamp,
-        // Trace context for distributed tracing
         traceId: error.traceId,
         spanId: error.spanId,
         service: error.service,
-        // Specific error fields
         retryAfter: error.retryAfter,
-        // Browser error details
         browserError: error.browserError,
-        // Context
         context: error.context,
-        // Additional details (sanitized - no sensitive info)
         details: sanitizeDetails(error.details),
-        // SDK metadata
         sdkVersion: SDK_VERSION,
         errorCapturedAt: new Date().toISOString()
     };
 }
-/**
- * Sanitize error details to remove sensitive information
- */
 function sanitizeDetails(details) {
     if (!details || typeof details !== 'object') {
         return details;
     }
-    // Clone the object
     const sanitized = JSON.parse(JSON.stringify(details));
-    // Remove sensitive fields
     const sensitiveFields = ['carrier', 'phone_number', 'mnc', 'mcc', 'carrier_name'];
     for (const field of sensitiveFields) {
         delete sanitized[field];
     }
     return sanitized;
 }
-/**
- * Create a breadcrumb trail for error tracking
- * Useful for understanding the sequence of events leading to an error
- */
 export function createErrorBreadcrumb(error) {
     var _a, _b, _c;
     return {

package/dist/esm/core/phone-auth/index.js

@@ -3,6 +3,4 @@ export * from './types';
 export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './error-utils';
 export { validatePhoneNumber, validatePlmn, validateUseCaseRequirements, validateNonce } from './validation-utils';
 export { MobileDebugConsole } from './ui/mobile-debug-console';
-export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, 
-// Deprecated aliases
-isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';
+export { isExtendedResponse, isCredential, isAuthCredential, isLinkStrategy, isTS43Strategy, isDesktopStrategy, getStrategy, hasPollingControls, hasTrigger, isHeadlessResult, requiresPolling, requiresUserAction } from './type-guards';

package/dist/esm/core/phone-auth/status-types.d.ts

@@ -1,69 +1,12 @@
-/**
- * Status Types for Public Status Endpoint
- *
- * These types define the response format for the public status endpoint
- * Used for polling authentication status without exposing sensitive data
- */
-/**
- * Status values returned by the public endpoint (HTTP 200 only)
- */
 export type AuthenticationStatus = 'pending' | 'completed';
-/**
- * Authentication protocol/strategy used
- */
 export type AuthenticationProtocol = 'ts43' | 'link' | 'desktop';
-/**
- * Public Status Response (HTTP 200 OK)
- *
- * This response is only returned with HTTP 200 status code
- * Failed/expired sessions return HTTP 4xx with ErrorResponse
- *
- * @example
- * ```typescript
- * // Public endpoint (no auth required)
- * const response = await fetch('/public/public/status/{sessionKey}');
- *
- * if (response.status === 200) {
- *   const status: StatusResponse = await response.json();
- *   if (status.status === 'completed') {
- *     // Authentication successful - now call process endpoint
- *     const result = await processAuthentication(sessionKey);
- *   }
- * } else if (response.status === 410) {
- *   // Session expired
- * } else if (response.status === 422) {
- *   // Authentication failed (user cancelled, etc.)
- * }
- * ```
- */
 export interface StatusResponse {
-    /**
-     * The session key/identifier
-     */
     session_key: string;
-    /**
-     * Current status of the authentication (only successful states)
-     */
     status: AuthenticationStatus;
-    /**
-     * Protocol/strategy used for authentication
-     * Optional - may not be present during pending state
-     */
     protocol?: AuthenticationProtocol;
-    /**
-     * ISO 8601 timestamp when session was created
-     */
     created_at: string;
-    /**
-     * ISO 8601 timestamp of last status update
-     */
     last_updated: string;
 }
-/**
- * Error Response (HTTP 4xx)
- *
- * Returned when session is expired, failed, or not found
- */
 export interface StatusErrorResponse {
     code: 'SESSION_EXPIRED' | 'USER_CANCELLED' | 'AUTHENTICATION_FAILED' | 'SESSION_NOT_FOUND' | 'INVALID_SESSION_KEY';
     message: string;
@@ -76,32 +19,11 @@ export interface StatusErrorResponse {
         duration_seconds?: number;
     };
 }
-/**
- * Type guard to check if authentication was successful
- */
 export declare function isSuccessStatus(status: AuthenticationStatus): boolean;
-/**
- * Helper to determine if polling should continue based on HTTP status
- */
 export declare function shouldContinuePolling(httpStatus: number, response?: StatusResponse): boolean;
-/**
- * Helper to determine if session is terminated based on HTTP status
- */
 export declare function isTerminalHttpStatus(httpStatus: number): boolean;
-/**
- * Session binding types for parent-child relationships
- */
 export interface SessionBinding {
-    /**
-     * Parent session ID (desktop QR code session)
-     */
     parent_session_id?: string;
-    /**
-     * Child session ID (mobile authentication session)
-     */
     child_session_id?: string;
-    /**
-     * Whether this is a parent or child session
-     */
     session_type?: 'parent' | 'child';
 }

package/dist/esm/core/phone-auth/status-types.js

@@ -1,26 +1,9 @@
-/**
- * Status Types for Public Status Endpoint
- *
- * These types define the response format for the public status endpoint
- * Used for polling authentication status without exposing sensitive data
- */
-/**
- * Type guard to check if authentication was successful
- */
 export function isSuccessStatus(status) {
     return status === 'completed';
 }
-/**
- * Helper to determine if polling should continue based on HTTP status
- */
 export function shouldContinuePolling(httpStatus, response) {
-    // Only continue if HTTP 200 and status is pending
     return httpStatus === 200 && (response === null || response === void 0 ? void 0 : response.status) === 'pending';
 }
-/**
- * Helper to determine if session is terminated based on HTTP status
- */
 export function isTerminalHttpStatus(httpStatus) {
-    // 410 Gone (expired), 422 Unprocessable (failed), 404 Not Found
     return httpStatus === 410 || httpStatus === 422 || httpStatus === 404;
 }

package/dist/esm/core/phone-auth/strategies/desktop.d.ts

@@ -1,13 +1,5 @@
-/**
- * Desktop Strategy Handler
- * Handles QR code-based authentication for desktop browsers
- * Manages QR code display and polling for authentication status
- */
 import type { StrategyHandler } from './types';
 import type { PrepareResponse } from '../types';
-/**
- * QR code data structure for dual-platform support
- */
 export interface QRCodeData {
     iosQRCode: string;
     androidQRCode?: string;
@@ -15,39 +7,24 @@ export interface QRCodeData {
     androidUrl?: string;
 }
 export interface DesktopAuthOptions {
-    /** Custom polling interval in milliseconds (overrides server-provided value) */
     pollingInterval?: number;
-    /** Maximum polling attempts before timeout (default: 30 = 1 minute with 2s interval) */
     maxPollingAttempts?: number;
-    /** Custom polling endpoint (overrides backend-provided or uses configured endpoint) */
     pollingEndpoint?: string;
-    /** Callback when QR code is ready to display */
     onQRCodeReady?: (qrCodeData: string | QRCodeData) => void;
-    /** Callback for polling status updates */
     onStatusUpdate?: (status: PollingStatus) => void;
-    /** Callback when authentication expires */
     onExpired?: () => void;
-    /** Callback when authentication is cancelled by user */
     onCancel?: () => void;
-    /** Callback when polling times out (max attempts reached) */
     onTimeout?: () => void;
 }
 export interface PollingStatus {
-    /** Current status of the authentication */
     status: 'pending' | 'authenticated' | 'expired' | 'cancelled' | 'error';
-    /** Optional message */
     message?: string;
-    /** Authentication result data if status is 'authenticated' */
     data?: any;
 }
 export interface DesktopAuthResult {
-    /** Whether authentication was successful */
     authenticated: boolean;
-    /** Authentication credential if successful */
     credential?: string;
-    /** Session info for subsequent requests */
     session?: any;
-    /** Error message if authentication failed */
     error?: string;
 }
 export declare class DesktopHandler implements StrategyHandler {
@@ -57,62 +34,22 @@ export declare class DesktopHandler implements StrategyHandler {
     private onCancel?;
     private pollingReject?;
     private isPollingInProgress;
-    /**
-     * Maps backend HTTP status codes to client status
-     * @param httpStatus HTTP status code from backend
-     * @param bodyStatus Optional status from response body (for 200 OK responses)
-     * @returns Mapped status string for client use
-     */
     private mapBackendStatus;
-    /**
-     * Invoke desktop authentication with QR code
-     * Returns QR code data for display and starts polling if endpoint is provided
-     */
     invoke(data: PrepareResponse, options?: DesktopAuthOptions): Promise<DesktopAuthResult>;
-    /**
-     * Start polling for authentication status
-     */
     private startPolling;
-    /**
-     * Stop polling
-     */
     private stopPolling;
-    /**
-     * Check if polling is currently active
-     */
     isPolling(): boolean;
-    /**
-     * Format response for backend processing
-     * Desktop strategy typically returns the credential from mobile authentication
-     */
     formatResponse(response: DesktopAuthResult): any;
-    /**
-     * Check if desktop authentication is supported
-     * Desktop auth with QR codes works in any modern browser
-     */
     isSupported(): boolean;
-    /**
-     * Clean up resources (stop polling if active)
-     */
     cleanup(): void;
-    /**
-     * Cancel the ongoing authentication
-     */
     cancel(): void;
 }
-/**
- * Helper function to display QR code in a modal or inline
- */
 export declare function createQRCodeDisplay(qrCodeData: string | QRCodeData, options?: {
     container?: HTMLElement;
     size?: number;
     title?: string;
     description?: string;
 }): HTMLElement;
-/**
- * Helper function to create a modal for QR code display
- * Supports both string QR codes and QRCodeData objects for dual-platform support
- */
 export declare function showQRCodeModal(qrCodeData: string | QRCodeData, options?: {
     title?: string;
     description?: string;