@oxyhq/core 1.0.0

package/dist/esm/utils/errorUtils.js

@@ -0,0 +1,146 @@
+import { logger } from './loggerUtils';
+/**
+ * Error handling utilities for consistent error processing
+ */
+/**
+ * Common error codes
+ */
+export const ErrorCodes = {
+    // Authentication errors
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    FORBIDDEN: 'FORBIDDEN',
+    INVALID_TOKEN: 'INVALID_TOKEN',
+    MISSING_TOKEN: 'MISSING_TOKEN',
+    // Validation errors
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    BAD_REQUEST: 'BAD_REQUEST',
+    MISSING_PARAMETER: 'MISSING_PARAMETER',
+    INVALID_FORMAT: 'INVALID_FORMAT',
+    // Resource errors
+    NOT_FOUND: 'NOT_FOUND',
+    ALREADY_EXISTS: 'ALREADY_EXISTS',
+    CONFLICT: 'CONFLICT',
+    // Server errors
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+    SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+    TIMEOUT: 'TIMEOUT',
+    // Network errors
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    CONNECTION_FAILED: 'CONNECTION_FAILED'
+};
+/**
+ * Create a standardized API error
+ */
+export function createApiError(message, code = ErrorCodes.INTERNAL_ERROR, status = 500, details) {
+    return {
+        message,
+        code,
+        status,
+        details
+    };
+}
+/**
+ * Handle common HTTP errors and convert to ApiError
+ */
+export function handleHttpError(error) {
+    // If it's already an ApiError, ensure it has a non-empty message
+    if (error && typeof error === 'object' && 'code' in error && 'status' in error) {
+        const apiError = error;
+        // Ensure message is not empty
+        if (!apiError.message || !apiError.message.trim()) {
+            return {
+                ...apiError,
+                message: apiError.message || 'An error occurred',
+            };
+        }
+        return apiError;
+    }
+    // Handle AbortError (timeout or cancelled requests)
+    if (error instanceof Error && error.name === 'AbortError') {
+        return createApiError('Request timeout or cancelled', ErrorCodes.TIMEOUT, 0);
+    }
+    // Handle TypeError (network failures, CORS, etc.)
+    if (error instanceof TypeError) {
+        // Check if it's a network-related TypeError
+        if (error.message.includes('fetch') || error.message.includes('network') || error.message.includes('Failed to fetch')) {
+            return createApiError('Network error - failed to connect to server', ErrorCodes.NETWORK_ERROR, 0);
+        }
+        return createApiError(error.message || 'Network error occurred', ErrorCodes.NETWORK_ERROR, 0);
+    }
+    // Handle fetch Response errors - check if it has response property with status
+    if (error && typeof error === 'object' && 'response' in error) {
+        const fetchError = error;
+        const status = fetchError.response?.status || fetchError.status;
+        if (status) {
+            return createApiError(fetchError.message || `HTTP ${status} error`, getErrorCodeFromStatus(status), status);
+        }
+    }
+    // Handle standard errors
+    if (error instanceof Error) {
+        // Check for common error patterns
+        if (error.message.includes('timeout') || error.message.includes('aborted')) {
+            return createApiError('Request timeout', ErrorCodes.TIMEOUT, 0);
+        }
+        if (error.message.includes('network') || error.message.includes('fetch')) {
+            return createApiError(error.message || 'Network error occurred', ErrorCodes.NETWORK_ERROR, 0);
+        }
+        return createApiError(error.message || 'Unknown error occurred', ErrorCodes.INTERNAL_ERROR, 500);
+    }
+    // Handle other errors - ensure we always return a non-empty message
+    const errorString = error ? String(error) : '';
+    const message = errorString.trim() || 'Unknown error occurred';
+    return createApiError(message, ErrorCodes.INTERNAL_ERROR, 500);
+}
+/**
+ * Get error code from HTTP status
+ * Exported for use in other modules
+ */
+export function getErrorCodeFromStatus(status) {
+    switch (status) {
+        case 400:
+            return ErrorCodes.BAD_REQUEST;
+        case 401:
+            return ErrorCodes.UNAUTHORIZED;
+        case 403:
+            return ErrorCodes.FORBIDDEN;
+        case 404:
+            return ErrorCodes.NOT_FOUND;
+        case 409:
+            return ErrorCodes.CONFLICT;
+        case 422:
+            return ErrorCodes.VALIDATION_ERROR;
+        case 500:
+            return ErrorCodes.INTERNAL_ERROR;
+        case 503:
+            return ErrorCodes.SERVICE_UNAVAILABLE;
+        default:
+            return ErrorCodes.INTERNAL_ERROR;
+    }
+}
+/**
+ * Validate required fields and throw error if missing
+ */
+export function validateRequiredFields(data, fields) {
+    const missing = fields.filter(field => !data[field]);
+    if (missing.length > 0) {
+        throw createApiError(`Missing required fields: ${missing.join(', ')}`, ErrorCodes.MISSING_PARAMETER, 400);
+    }
+}
+/**
+ * Safe error logging with context
+ */
+export function logError(error, context) {
+    if (error instanceof Error) {
+        logger.error(error.message, {
+            component: context || 'errorUtils',
+            method: 'logError',
+            stack: error.stack,
+        });
+    }
+    else {
+        logger.error(String(error), {
+            component: context || 'errorUtils',
+            method: 'logError',
+        });
+    }
+}

package/dist/esm/utils/index.js

@@ -0,0 +1,7 @@
+export { DeviceManager } from './deviceManager';
+// Request utilities
+export { RequestDeduplicator, RequestQueue, SimpleLogger } from './requestUtils';
+// Cache utilities
+export { TTLCache, createCache, registerCacheForCleanup, unregisterCacheFromCleanup } from './cache';
+// Session utilities
+export { normalizeSession, sortSessions, deduplicateSessions, deduplicateSessionsByUserId, normalizeAndSortSessions, mergeSessions, sessionsEqual, sessionsArraysEqual } from './sessionUtils';

package/dist/esm/utils/languageUtils.js

@@ -0,0 +1,158 @@
+/**
+ * Language utilities for OxyServices
+ * Provides access to supported languages and language metadata
+ */
+// Supported languages with their metadata
+export const SUPPORTED_LANGUAGES = [
+    {
+        id: 'en-US',
+        name: 'English',
+        nativeName: 'English',
+        flag: '🇺🇸',
+        icon: 'translate',
+        color: '#007AFF',
+    },
+    {
+        id: 'es-ES',
+        name: 'Spanish',
+        nativeName: 'Español',
+        flag: '🇪🇸',
+        icon: 'translate',
+        color: '#FF3B30',
+    },
+    {
+        id: 'ca-ES',
+        name: 'Catalan',
+        nativeName: 'Català',
+        flag: '🇪🇸',
+        icon: 'translate',
+        color: '#0CA678',
+    },
+    {
+        id: 'fr-FR',
+        name: 'French',
+        nativeName: 'Français',
+        flag: '🇫🇷',
+        icon: 'translate',
+        color: '#5856D6',
+    },
+    {
+        id: 'de-DE',
+        name: 'German',
+        nativeName: 'Deutsch',
+        flag: '🇩🇪',
+        icon: 'translate',
+        color: '#FF9500',
+    },
+    {
+        id: 'it-IT',
+        name: 'Italian',
+        nativeName: 'Italiano',
+        flag: '🇮🇹',
+        icon: 'translate',
+        color: '#34C759',
+    },
+    {
+        id: 'pt-PT',
+        name: 'Portuguese',
+        nativeName: 'Português',
+        flag: '🇵🇹',
+        icon: 'translate',
+        color: '#AF52DE',
+    },
+    {
+        id: 'ja-JP',
+        name: 'Japanese',
+        nativeName: '日本語',
+        flag: '🇯🇵',
+        icon: 'translate',
+        color: '#FF2D92',
+    },
+    {
+        id: 'ko-KR',
+        name: 'Korean',
+        nativeName: '한국어',
+        flag: '🇰🇷',
+        icon: 'translate',
+        color: '#32D74B',
+    },
+    {
+        id: 'zh-CN',
+        name: 'Chinese',
+        nativeName: '中文',
+        flag: '🇨🇳',
+        icon: 'translate',
+        color: '#FF9F0A',
+    },
+    {
+        id: 'ar-SA',
+        name: 'Arabic',
+        nativeName: 'العربية',
+        flag: '🇸🇦',
+        icon: 'translate',
+        color: '#30B0C7',
+    },
+];
+const FALLBACK_LANGUAGE = 'en-US';
+/**
+ * Get language metadata by language code
+ * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
+ * @returns Language metadata or null if not found
+ */
+export function getLanguageMetadata(languageCode) {
+    if (!languageCode)
+        return null;
+    // Direct match
+    const exactMatch = SUPPORTED_LANGUAGES.find(lang => lang.id === languageCode);
+    if (exactMatch)
+        return exactMatch;
+    // Try to match base language code (e.g., 'en' matches 'en-US')
+    const baseCode = languageCode.split('-')[0];
+    const baseMatch = SUPPORTED_LANGUAGES.find(lang => lang.id.startsWith(baseCode + '-'));
+    if (baseMatch)
+        return baseMatch;
+    return null;
+}
+/**
+ * Get language name by language code
+ * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
+ * @returns Language name (e.g., 'English') or the code if not found
+ */
+export function getLanguageName(languageCode) {
+    const metadata = getLanguageMetadata(languageCode);
+    return metadata?.name || languageCode || FALLBACK_LANGUAGE;
+}
+/**
+ * Get native language name by language code
+ * @param languageCode - BCP-47 language code (e.g., 'en-US', 'es-ES')
+ * @returns Native language name (e.g., 'Español') or the code if not found
+ */
+export function getNativeLanguageName(languageCode) {
+    const metadata = getLanguageMetadata(languageCode);
+    return metadata?.nativeName || languageCode || FALLBACK_LANGUAGE;
+}
+/**
+ * Normalize language code to BCP-47 format
+ * @param lang - Language code (may be short like 'en' or full like 'en-US')
+ * @returns Normalized BCP-47 language code
+ */
+export function normalizeLanguageCode(lang) {
+    if (!lang)
+        return FALLBACK_LANGUAGE;
+    if (lang.includes('-'))
+        return lang;
+    const map = {
+        en: 'en-US',
+        es: 'es-ES',
+        ca: 'ca-ES',
+        fr: 'fr-FR',
+        de: 'de-DE',
+        it: 'it-IT',
+        pt: 'pt-PT',
+        ja: 'ja-JP',
+        ko: 'ko-KR',
+        zh: 'zh-CN',
+        ar: 'ar-SA',
+    };
+    return map[lang] || lang;
+}

package/dist/esm/utils/loggerUtils.js

@@ -0,0 +1,115 @@
+/**
+ * Centralized logging utilities for consistent logging across the application
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (LogLevel = {}));
+class Logger {
+    constructor() {
+        this.level = LogLevel.INFO;
+        this.isDevelopment = process.env.NODE_ENV === 'development';
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    shouldLog(level) {
+        return level >= this.level;
+    }
+    formatMessage(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const contextStr = context ? ` [${Object.entries(context).map(([k, v]) => `${k}:${v}`).join(', ')}]` : '';
+        return `[${timestamp}] ${level}${contextStr}: ${message}`;
+    }
+    debug(message, context, ...args) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            const formattedMessage = this.formatMessage('DEBUG', message, context);
+            if (this.isDevelopment) {
+                console.log(formattedMessage, ...args);
+            }
+        }
+    }
+    info(message, context, ...args) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            const formattedMessage = this.formatMessage('INFO', message, context);
+            console.log(formattedMessage, ...args);
+        }
+    }
+    warn(message, context, ...args) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            const formattedMessage = this.formatMessage('WARN', message, context);
+            console.warn(formattedMessage, ...args);
+        }
+    }
+    error(message, error, context, ...args) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const formattedMessage = this.formatMessage('ERROR', message, context);
+            if (error) {
+                console.error(formattedMessage, error, ...args);
+            }
+            else {
+                console.error(formattedMessage, ...args);
+            }
+        }
+    }
+    // Specialized logging methods for common patterns
+    auth(message, context, ...args) {
+        this.info(`🔐 ${message}`, { ...context, category: 'auth' }, ...args);
+    }
+    api(message, context, ...args) {
+        this.info(`🌐 ${message}`, { ...context, category: 'api' }, ...args);
+    }
+    session(message, context, ...args) {
+        this.info(`📱 ${message}`, { ...context, category: 'session' }, ...args);
+    }
+    user(message, context, ...args) {
+        this.info(`👤 ${message}`, { ...context, category: 'user' }, ...args);
+    }
+    device(message, context, ...args) {
+        this.info(`📱 ${message}`, { ...context, category: 'device' }, ...args);
+    }
+    payment(message, context, ...args) {
+        this.info(`💳 ${message}`, { ...context, category: 'payment' }, ...args);
+    }
+    // Performance logging
+    performance(operation, duration, context) {
+        const level = duration > 1000 ? LogLevel.WARN : LogLevel.INFO;
+        const message = `⏱️ ${operation} completed in ${duration}ms`;
+        if (level === LogLevel.WARN) {
+            this.warn(message, { ...context, category: 'performance', duration });
+        }
+        else {
+            this.info(message, { ...context, category: 'performance', duration });
+        }
+    }
+    // Error logging with stack trace
+    errorWithStack(message, error, context) {
+        this.error(message, error, { ...context, stack: error.stack });
+    }
+    // Group related log messages
+    group(label, fn) {
+        if (this.isDevelopment && this.shouldLog(LogLevel.DEBUG)) {
+            console.group(label);
+            fn();
+            console.groupEnd();
+        }
+        else {
+            fn();
+        }
+    }
+}
+// Create singleton instance
+export const logger = new Logger();
+// Convenience functions for common logging patterns
+export const logAuth = (message, context, ...args) => logger.auth(message, context, ...args);
+export const logApi = (message, context, ...args) => logger.api(message, context, ...args);
+export const logSession = (message, context, ...args) => logger.session(message, context, ...args);
+export const logUser = (message, context, ...args) => logger.user(message, context, ...args);
+export const logDevice = (message, context, ...args) => logger.device(message, context, ...args);
+export const logPayment = (message, context, ...args) => logger.payment(message, context, ...args);
+export const logError = (message, error, context, ...args) => logger.error(message, error, context, ...args);
+export const logPerformance = (operation, duration, context) => logger.performance(operation, duration, context);

package/dist/esm/utils/platform.js

@@ -0,0 +1,102 @@
+/**
+ * Platform Detection Utility
+ *
+ * Provides platform detection WITHOUT importing from 'react-native'.
+ * This allows core modules to be used in web/Node.js environments
+ * without bundlers failing on react-native imports.
+ */
+/**
+ * Detect the current platform without importing react-native
+ *
+ * Detection order:
+ * 1. Check for React Native's Platform object on globalThis (set by RN runtime)
+ * 2. Check for Node.js environment
+ * 3. Check for browser environment
+ * 4. Fall back to 'unknown'
+ */
+function detectPlatform() {
+    // Check if React Native Platform is available globally (set by RN runtime)
+    // This avoids static imports while still detecting RN environment
+    const rnPlatform = globalThis.__REACT_NATIVE_PLATFORM__;
+    if (rnPlatform) {
+        return rnPlatform;
+    }
+    // Check navigator.product for React Native
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        // We're in React Native but Platform wasn't set globally
+        // Try to get OS from userAgent or default to 'unknown'
+        return 'unknown';
+    }
+    // Check for Node.js environment
+    if (typeof process !== 'undefined' && process.versions?.node) {
+        return 'web'; // Treat Node.js as 'web' for compatibility (no native features)
+    }
+    // Check for browser/web environment
+    if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+        return 'web';
+    }
+    return 'unknown';
+}
+// Cache the platform detection result
+let cachedPlatform = null;
+/**
+ * Get the current platform OS
+ * Safe to call from any environment (web, Node.js, React Native)
+ */
+export function getPlatformOS() {
+    if (cachedPlatform === null) {
+        cachedPlatform = detectPlatform();
+    }
+    return cachedPlatform;
+}
+/**
+ * Check if running on web platform (browser or Node.js)
+ */
+export function isWeb() {
+    return getPlatformOS() === 'web';
+}
+/**
+ * Check if running in a native app (iOS or Android)
+ */
+export function isNative() {
+    const os = getPlatformOS();
+    return os === 'ios' || os === 'android';
+}
+/**
+ * Check if running on iOS
+ */
+export function isIOS() {
+    return getPlatformOS() === 'ios';
+}
+/**
+ * Check if running on Android
+ */
+export function isAndroid() {
+    return getPlatformOS() === 'android';
+}
+/**
+ * Set the platform OS explicitly
+ * Called by React Native entry point to register the platform
+ * This allows lazy detection in environments where react-native is available
+ */
+export function setPlatformOS(os) {
+    cachedPlatform = os;
+    globalThis.__REACT_NATIVE_PLATFORM__ = os;
+}
+/**
+ * Try to initialize platform from react-native if available
+ * This is called lazily when needed, avoiding top-level imports
+ */
+export async function initPlatformFromReactNative() {
+    if (cachedPlatform !== null && cachedPlatform !== 'unknown') {
+        return; // Already initialized
+    }
+    try {
+        // Dynamic import to avoid bundler issues
+        const { Platform } = await import('react-native');
+        setPlatformOS(Platform.OS);
+    }
+    catch {
+        // react-native not available, use detected platform
+    }
+}