@oxyhq/core 1.0.0

package/dist/cjs/utils/languageUtils.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Language utilities for OxyServices
+ * Provides access to supported languages and language metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_LANGUAGES = void 0;
+exports.getLanguageMetadata = getLanguageMetadata;
+exports.getLanguageName = getLanguageName;
+exports.getNativeLanguageName = getNativeLanguageName;
+exports.normalizeLanguageCode = normalizeLanguageCode;
+// Supported languages with their metadata
+exports.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
+ */
+function getLanguageMetadata(languageCode) {
+    if (!languageCode)
+        return null;
+    // Direct match
+    const exactMatch = exports.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 = exports.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
+ */
+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
+ */
+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
+ */
+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/cjs/utils/loggerUtils.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Centralized logging utilities for consistent logging across the application
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logPerformance = exports.logError = exports.logPayment = exports.logDevice = exports.logUser = exports.logSession = exports.logApi = exports.logAuth = exports.logger = exports.LogLevel = void 0;
+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 || (exports.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
+exports.logger = new Logger();
+// Convenience functions for common logging patterns
+const logAuth = (message, context, ...args) => exports.logger.auth(message, context, ...args);
+exports.logAuth = logAuth;
+const logApi = (message, context, ...args) => exports.logger.api(message, context, ...args);
+exports.logApi = logApi;
+const logSession = (message, context, ...args) => exports.logger.session(message, context, ...args);
+exports.logSession = logSession;
+const logUser = (message, context, ...args) => exports.logger.user(message, context, ...args);
+exports.logUser = logUser;
+const logDevice = (message, context, ...args) => exports.logger.device(message, context, ...args);
+exports.logDevice = logDevice;
+const logPayment = (message, context, ...args) => exports.logger.payment(message, context, ...args);
+exports.logPayment = logPayment;
+const logError = (message, error, context, ...args) => exports.logger.error(message, error, context, ...args);
+exports.logError = logError;
+const logPerformance = (operation, duration, context) => exports.logger.performance(operation, duration, context);
+exports.logPerformance = logPerformance;

package/dist/cjs/utils/platform.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformOS = getPlatformOS;
+exports.isWeb = isWeb;
+exports.isNative = isNative;
+exports.isIOS = isIOS;
+exports.isAndroid = isAndroid;
+exports.setPlatformOS = setPlatformOS;
+exports.initPlatformFromReactNative = initPlatformFromReactNative;
+/**
+ * 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)
+ */
+function getPlatformOS() {
+    if (cachedPlatform === null) {
+        cachedPlatform = detectPlatform();
+    }
+    return cachedPlatform;
+}
+/**
+ * Check if running on web platform (browser or Node.js)
+ */
+function isWeb() {
+    return getPlatformOS() === 'web';
+}
+/**
+ * Check if running in a native app (iOS or Android)
+ */
+function isNative() {
+    const os = getPlatformOS();
+    return os === 'ios' || os === 'android';
+}
+/**
+ * Check if running on iOS
+ */
+function isIOS() {
+    return getPlatformOS() === 'ios';
+}
+/**
+ * Check if running on Android
+ */
+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
+ */
+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
+ */
+async function initPlatformFromReactNative() {
+    if (cachedPlatform !== null && cachedPlatform !== 'unknown') {
+        return; // Already initialized
+    }
+    try {
+        // Dynamic import to avoid bundler issues
+        const { Platform } = await Promise.resolve().then(() => __importStar(require('react-native')));
+        setPlatformOS(Platform.OS);
+    }
+    catch {
+        // react-native not available, use detected platform
+    }
+}

package/dist/cjs/utils/requestUtils.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Request utilities for HTTP clients
+ *
+ * Provides reusable components for request deduplication, queuing, and logging
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLogger = exports.RequestQueue = exports.RequestDeduplicator = void 0;
+/**
+ * Request deduplication - prevents duplicate concurrent requests
+ *
+ * When multiple requests with the same key are made simultaneously,
+ * only one request is executed and all callers receive the same result.
+ *
+ * @example
+ * ```typescript
+ * const deduplicator = new RequestDeduplicator();
+ *
+ * // Multiple calls with same key will share the same promise
+ * const promise1 = deduplicator.deduplicate('user-123', () => fetchUser('123'));
+ * const promise2 = deduplicator.deduplicate('user-123', () => fetchUser('123'));
+ * // promise1 === promise2, only one API call is made
+ * ```
+ */
+class RequestDeduplicator {
+    constructor() {
+        this.pendingRequests = new Map();
+    }
+    /**
+     * Deduplicate a request by key
+     * @param key Unique key for the request
+     * @param requestFn Function that returns a promise
+     * @returns Promise that will be shared if key already exists
+     */
+    async deduplicate(key, requestFn) {
+        const existing = this.pendingRequests.get(key);
+        if (existing) {
+            return existing;
+        }
+        const promise = requestFn()
+            .finally(() => {
+            this.pendingRequests.delete(key);
+        });
+        this.pendingRequests.set(key, promise);
+        return promise;
+    }
+    /**
+     * Clear all pending requests
+     */
+    clear() {
+        this.pendingRequests.clear();
+    }
+    /**
+     * Get number of pending requests
+     */
+    size() {
+        return this.pendingRequests.size;
+    }
+}
+exports.RequestDeduplicator = RequestDeduplicator;
+/**
+ * Request queue with concurrency control
+ *
+ * Limits the number of concurrent requests and queues excess requests.
+ * Useful for rate limiting and preventing request flooding.
+ *
+ * @example
+ * ```typescript
+ * const queue = new RequestQueue(5, 100); // Max 5 concurrent, queue up to 100
+ *
+ * // All requests will be queued and processed with max 5 concurrent
+ * await queue.enqueue(() => fetchUser('1'));
+ * await queue.enqueue(() => fetchUser('2'));
+ * // ...
+ * ```
+ */
+class RequestQueue {
+    /**
+     * Create a new request queue
+     * @param maxConcurrent Maximum number of concurrent requests (default: 10)
+     * @param maxQueueSize Maximum queue size (default: 100)
+     */
+    constructor(maxConcurrent = 10, maxQueueSize = 100) {
+        this.queue = [];
+        this.running = 0;
+        this.maxConcurrent = maxConcurrent;
+        this.maxQueueSize = maxQueueSize;
+    }
+    /**
+     * Enqueue a request
+     * @param requestFn Function that returns a promise
+     * @returns Promise that resolves when request completes
+     */
+    async enqueue(requestFn) {
+        if (this.queue.length >= this.maxQueueSize) {
+            throw new Error('Request queue is full');
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push(async () => {
+                try {
+                    const result = await requestFn();
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            this.process();
+        });
+    }
+    /**
+     * Process queued requests
+     */
+    async process() {
+        if (this.running >= this.maxConcurrent || this.queue.length === 0) {
+            return;
+        }
+        this.running++;
+        const requestFn = this.queue.shift();
+        if (requestFn) {
+            try {
+                await requestFn();
+            }
+            finally {
+                this.running--;
+                this.process();
+            }
+        }
+        else {
+            this.running--;
+        }
+    }
+    /**
+     * Clear all queued requests
+     */
+    clear() {
+        this.queue = [];
+    }
+    /**
+     * Get queue size
+     */
+    size() {
+        return this.queue.length;
+    }
+    /**
+     * Get number of currently running requests
+     */
+    runningCount() {
+        return this.running;
+    }
+}
+exports.RequestQueue = RequestQueue;
+/**
+ * Simple logger with level support
+ *
+ * Lightweight logger for HTTP clients and utilities.
+ * For more advanced logging, use loggerUtils.ts
+ *
+ * @example
+ * ```typescript
+ * const logger = new SimpleLogger(true, 'debug');
+ * logger.debug('Debug message');
+ * logger.info('Info message');
+ * logger.error('Error message');
+ * ```
+ */
+class SimpleLogger {
+    /**
+     * Create a new simple logger
+     * @param enabled Whether logging is enabled
+     * @param level Minimum log level
+     * @param prefix Prefix for log messages (default: '')
+     */
+    constructor(enabled = false, level = 'error', prefix = '') {
+        this.enabled = enabled;
+        this.level = level;
+        this.prefix = prefix;
+    }
+    shouldLog(level) {
+        if (!this.enabled || this.level === 'none')
+            return false;
+        const levels = ['none', 'error', 'warn', 'info', 'debug'];
+        return levels.indexOf(level) <= levels.indexOf(this.level);
+    }
+    formatMessage(...args) {
+        return this.prefix ? [`[${this.prefix}]`, ...args] : args;
+    }
+    error(...args) {
+        if (this.shouldLog('error')) {
+            console.error(...this.formatMessage(...args));
+        }
+    }
+    warn(...args) {
+        if (this.shouldLog('warn')) {
+            console.warn(...this.formatMessage(...args));
+        }
+    }
+    info(...args) {
+        if (this.shouldLog('info')) {
+            console.info(...this.formatMessage(...args));
+        }
+    }
+    debug(...args) {
+        if (this.shouldLog('debug')) {
+            console.log(...this.formatMessage(...args));
+        }
+    }
+}
+exports.SimpleLogger = SimpleLogger;