@glideidentity/web-client-sdk 4.4.8-beta.1

package/dist/esm/adapters/vue/usePhoneAuth.d.ts

@@ -0,0 +1,94 @@
+import { PhoneAuthClient } from '../../core/phone-auth';
+import type { AuthConfig, AuthStep, PhoneAuthOptions } from '../../core/phone-auth';
+import * as API from '../../core/phone-auth/api-types';
+export interface UsePhoneAuthOptions extends AuthConfig {
+}
+export declare function usePhoneAuth(config?: UsePhoneAuthOptions): {
+    isLoading: Readonly<import("vue").Ref<boolean, boolean>>;
+    error: Readonly<import("vue").Ref<{
+        readonly code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+        readonly message: string;
+        readonly details?: any;
+        readonly status?: number | undefined;
+        readonly requestId?: string | undefined;
+        readonly timestamp?: string | undefined;
+        readonly traceId?: string | undefined;
+        readonly spanId?: string | undefined;
+        readonly service?: string | undefined;
+        readonly retryAfter?: number | undefined;
+        readonly browserError?: {
+            name: string;
+            message: string;
+            stack?: string;
+            code?: number;
+        } | undefined;
+        readonly context?: {
+            readonly [x: string]: any;
+            readonly step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+            readonly useCase?: string | undefined;
+            readonly timestamp: string;
+            readonly userAgent?: string | undefined;
+            readonly url?: string | undefined;
+        } | undefined;
+    } | null, {
+        readonly code: import("../../core/phone-auth/types").PhoneAuthErrorCode;
+        readonly message: string;
+        readonly details?: any;
+        readonly status?: number | undefined;
+        readonly requestId?: string | undefined;
+        readonly timestamp?: string | undefined;
+        readonly traceId?: string | undefined;
+        readonly spanId?: string | undefined;
+        readonly service?: string | undefined;
+        readonly retryAfter?: number | undefined;
+        readonly browserError?: {
+            name: string;
+            message: string;
+            stack?: string;
+            code?: number;
+        } | undefined;
+        readonly context?: {
+            readonly [x: string]: any;
+            readonly step?: "prepare" | "prompt" | "process" | "complete" | undefined;
+            readonly useCase?: string | undefined;
+            readonly timestamp: string;
+            readonly userAgent?: string | undefined;
+            readonly url?: string | undefined;
+        } | undefined;
+    } | null>>;
+    result: Readonly<import("vue").Ref<{
+        readonly phone_number: API.PhoneNumber;
+        readonly aud?: string | undefined;
+    } | {
+        readonly phone_number: API.PhoneNumber;
+        readonly verified: boolean;
+        readonly aud?: string | undefined;
+    } | null, {
+        readonly phone_number: API.PhoneNumber;
+        readonly aud?: string | undefined;
+    } | {
+        readonly phone_number: API.PhoneNumber;
+        readonly verified: boolean;
+        readonly aud?: string | undefined;
+    } | null>>;
+    currentStep: Readonly<import("vue").Ref<AuthStep, AuthStep>>;
+    isSupported: Readonly<import("vue").Ref<boolean, boolean>>;
+    verify: (options: PhoneAuthOptions) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    getPhoneNumber: (options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    verifyPhoneNumber: (phoneNumber: string, options?: Omit<PhoneAuthOptions, "use_case" | "phone_number">) => Promise<{
+        phone_number: API.PhoneNumber;
+        aud?: string | undefined;
+    }>;
+    reset: () => void;
+    preparePhoneRequest: (options: PhoneAuthOptions) => Promise<API.PrepareResponse>;
+    invokeSecurePrompt: (prepareResponse: API.PrepareResponse, options?: API.InvokeOptions | import("../..").DesktopAuthOptions) => Promise<API.SecureCredentialResponse["vp_token"] | API.HeadlessResult>;
+    getPhoneNumberCredential: (credentialResponse: API.SecureCredentialResponse["vp_token"] | string, session: API.SessionInfo) => Promise<API.GetPhoneNumberResponse>;
+    verifyPhoneNumberCredential: (credentialResponse: API.SecureCredentialResponse["vp_token"] | string, session: API.SessionInfo) => Promise<API.VerifyPhoneNumberResponse>;
+    client: PhoneAuthClient;
+};

package/dist/esm/adapters/vue/usePhoneAuth.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ref, computed, readonly } from 'vue';
+import { PhoneAuthClient } from '../../core/phone-auth';
+export function usePhoneAuth(config = {}) {
+    // State management
+    const isLoading = ref(false);
+    const error = ref(null);
+    const result = ref(null);
+    const currentStep = ref('idle');
+    // Create client instance with callbacks
+    const client = new PhoneAuthClient(Object.assign(Object.assign({}, config), { 
+        // Callbacks are now properly typed through AuthConfig
+        onCrossDeviceDetected: config.onCrossDeviceDetected, onRetryAttempt: config.onRetryAttempt }));
+    // Check browser support
+    const isSupported = computed(() => client.isSupported());
+    // Verify method - internal wrapper that converts to API format
+    const verify = (options) => __awaiter(this, void 0, void 0, function* () {
+        isLoading.value = true;
+        error.value = null;
+        result.value = null;
+        currentStep.value = 'requesting';
+        try {
+            // Step 1: Prepare the request
+            const preparedRequest = yield client.preparePhoneRequest(options);
+            // Step 2: User authentication
+            currentStep.value = 'authenticating';
+            const credentialResponse = yield client.invokeSecurePrompt(preparedRequest);
+            // Step 3: Process the response through appropriate endpoint
+            currentStep.value = 'processing';
+            // Cast to credential type - adapters never use headless mode
+            const credential = credentialResponse;
+            const verificationResult = options.use_case === 'GetPhoneNumber'
+                ? yield client.getPhoneNumber(credential, preparedRequest.session)
+                : yield client.verifyPhoneNumber(credential, preparedRequest.session);
+            // Use the result directly - it's already the correct type
+            result.value = verificationResult;
+            currentStep.value = 'complete';
+            return result.value;
+        }
+        catch (err) {
+            // Enhance error with context if it's an AuthError
+            const authError = err;
+            const enhancedError = Object.assign(Object.assign({}, authError), { context: authError.context || {
+                    useCase: options.use_case,
+                    timestamp: new Date().toISOString(),
+                    userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
+                    url: typeof window !== 'undefined' ? window.location.href : undefined
+                } });
+            error.value = enhancedError;
+            currentStep.value = 'idle';
+            throw enhancedError;
+        }
+        finally {
+            isLoading.value = false;
+        }
+    });
+    // Convenience methods
+    const getPhoneNumber = (options) => verify(Object.assign({ use_case: 'GetPhoneNumber' }, options));
+    const verifyPhoneNumber = (phoneNumber, options) => verify(Object.assign({ use_case: 'VerifyPhoneNumber', phone_number: phoneNumber }, options));
+    // Reset state
+    const reset = () => {
+        isLoading.value = false;
+        error.value = null;
+        result.value = null;
+        currentStep.value = 'idle';
+    };
+    // Expose granular methods directly from client for better discoverability
+    const preparePhoneRequest = client.preparePhoneRequest.bind(client);
+    const invokeSecurePrompt = client.invokeSecurePrompt.bind(client);
+    const getPhoneNumberCredential = client.getPhoneNumber.bind(client);
+    const verifyPhoneNumberCredential = client.verifyPhoneNumber.bind(client);
+    return {
+        // State (readonly)
+        isLoading: readonly(isLoading),
+        error: readonly(error),
+        result: readonly(result),
+        currentStep: readonly(currentStep),
+        isSupported: readonly(isSupported),
+        // High-level methods
+        verify,
+        getPhoneNumber,
+        verifyPhoneNumber,
+        reset,
+        // Granular methods (directly exposed for better discoverability)
+        preparePhoneRequest,
+        invokeSecurePrompt,
+        getPhoneNumberCredential,
+        verifyPhoneNumberCredential,
+        // Client instance (still available for advanced usage)
+        client
+    };
+}

package/dist/esm/browser.d.ts

@@ -0,0 +1,7 @@
+export { PhoneAuthClient } from './core/phone-auth';
+export type { AuthConfig as PhoneAuthConfig, PhoneAuthOptions, PhoneAuthResult, AuthError as PhoneAuthError, AuthStep as PhoneAuthStep } from './core/phone-auth';
+export { PhoneAuthErrorCode, isPhoneAuthError, isUserError, getUserMessage, isErrorCode, getRetryDelay, isRetryableError, serializeError, createErrorBreadcrumb } from './core/phone-auth';
+export type { PhoneAuthCallbacks, PLMN, SessionInfo, PrepareRequest, PrepareResponse, GetPhoneNumberRequest, GetPhoneNumberResponse, VerifyPhoneNumberRequest, VerifyPhoneNumberResponse, SecureCredentialRequest, SecureCredentialResponse, DigitalCredential, TS43Data, LinkData, ClientInfo, ConsentData, BrowserErrorType, BrowserErrorCodeType, BrowserNameType } from './core/phone-auth/types';
+export { USE_CASE as UseCase, AUTHENTICATION_STRATEGY as AuthenticationStrategy, BrowserError, BrowserErrorCode, BrowserName } from './core/phone-auth/types';
+export { VanillaClient as ClientManager } from './adapters/vanilla/client';
+export { PhoneAuthManager } from './adapters/vanilla/phone-auth';

package/dist/esm/browser.js

@@ -0,0 +1,11 @@
+// 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';

package/dist/esm/core/client.d.ts

@@ -0,0 +1,22 @@
+import { ClientConfig, RequestOptions, ClientResponse } from './types';
+import { PhoneAuthClient } from './phone-auth';
+export declare class SDKClient {
+    private client;
+    private config;
+    private token?;
+    phoneAuth: PhoneAuthClient;
+    constructor(config: ClientConfig);
+    /**
+     * Set authentication token for API requests
+     */
+    setToken(token: string): void;
+    /**
+     * Clear authentication token
+     */
+    clearToken(): void;
+    /**
+     * Make a GET request to the API
+     * Note: Requires baseURL to be set in the config
+     */
+    get<T = any>(path: string, options?: RequestOptions): Promise<ClientResponse<T>>;
+}

package/dist/esm/core/client.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import axios from 'axios';
+import { PhoneAuthClient } from './phone-auth';
+export class SDKClient {
+    constructor(config) {
+        this.config = config;
+        this.client = axios.create({
+            baseURL: config.baseURL || '',
+            timeout: config.timeout || 10000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Initialize Phone Auth client
+        this.phoneAuth = new PhoneAuthClient({
+            endpoints: config.phoneAuthEndpoints ? {
+                prepare: config.phoneAuthEndpoints.prepareRequest,
+                process: config.phoneAuthEndpoints.processResponse
+            } : undefined,
+            debug: config.debug
+        });
+        // Add authentication interceptor
+        this.client.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
+            if (this.token) {
+                config.headers.Authorization = `Bearer ${this.token}`;
+            }
+            return config;
+        }));
+    }
+    /**
+     * Set authentication token for API requests
+     */
+    setToken(token) {
+        this.token = token;
+    }
+    /**
+     * Clear authentication token
+     */
+    clearToken() {
+        this.token = undefined;
+    }
+    /**
+     * Make a GET request to the API
+     * Note: Requires baseURL to be set in the config
+     */
+    get(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.config.baseURL) {
+                throw new Error('baseURL is required for making API requests. Please provide it in the ClientConfig.');
+            }
+            const response = yield this.client.get(path, {
+                headers: options === null || options === void 0 ? void 0 : options.headers,
+                params: options === null || options === void 0 ? void 0 : options.params,
+            });
+            return {
+                data: response.data,
+                status: response.status,
+                headers: Object.fromEntries(Object.entries(response.headers).map(([k, v]) => [k, String(v)])),
+            };
+        });
+    }
+}

package/dist/esm/core/logger.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Industry-grade logging for Glide Web SDK
+ * Following best practices from Stripe, Auth0, Twilio, and AWS Amplify
+ */
+export declare enum LogLevel {
+    SILENT = 0,
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export interface LogFields {
+    [key: string]: any;
+}
+export interface Logger {
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+}
+/**
+ * Default browser console logger with automatic data sanitization
+ */
+export declare class ConsoleLogger implements Logger {
+    private level;
+    private prefix;
+    private enableGrouping;
+    constructor(level?: LogLevel, prefix?: string, enableGrouping?: boolean);
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+    private log;
+    /**
+     * Sanitize sensitive data from log fields
+     */
+    private sanitizeFields;
+    /**
+     * Redact sensitive information based on field name and value patterns
+     */
+    private sanitizeValue;
+}
+/**
+ * No-op logger for when logging is disabled
+ */
+export declare class NoopLogger implements Logger {
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+}
+/**
+ * Remote logger for sending logs to a backend service
+ * Useful for debugging production issues
+ */
+export declare class RemoteLogger implements Logger {
+    private endpoint;
+    private apiKey;
+    private localLogger;
+    private buffer;
+    private flushInterval;
+    private maxBufferSize;
+    constructor(endpoint: string, apiKey: string, fallbackLogger?: Logger);
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+    private log;
+    private flush;
+}
+/**
+ * Parse log level from string
+ */
+export declare function parseLogLevel(level: string): LogLevel;
+/**
+ * Get log level from browser environment
+ */
+export declare function getLogLevelFromEnv(): LogLevel;
+/**
+ * Performance timer for measuring operation duration
+ */
+export declare class PerformanceTimer {
+    private startTime;
+    private marks;
+    private logger;
+    constructor(logger: Logger);
+    /**
+     * Mark a point in time
+     */
+    mark(name: string): void;
+    /**
+     * Log elapsed time with optional fields
+     */
+    logElapsed(message: string, fields?: LogFields): void;
+    /**
+     * Log time between marks
+     */
+    logMarkDuration(fromMark: string, toMark: string, message: string, fields?: LogFields): void;
+}
+/**
+ * Generate a unique request ID for distributed tracing
+ */
+export declare function generateRequestId(): string;
+/**
+ * Logger factory for creating loggers with consistent configuration
+ */
+export declare class LoggerFactory {
+    private static defaultLevel;
+    private static defaultLogger;
+    /**
+     * Set the default log level for all new loggers
+     */
+    static setDefaultLevel(level: LogLevel): void;
+    /**
+     * Set a default logger instance to use
+     */
+    static setDefaultLogger(logger: Logger): void;
+    /**
+     * Create a logger instance based on configuration
+     */
+    static create(options?: {
+        level?: LogLevel;
+        prefix?: string;
+        remote?: {
+            endpoint: string;
+            apiKey: string;
+        };
+        custom?: Logger;
+    }): Logger;
+}