@oxyhq/services 5.26.4 → 6.0.0

package/src/utils/languageUtils.ts

@@ -1,174 +0,0 @@
-/**
- * Language utilities for OxyServices
- * Provides access to supported languages and language metadata
- */
-
-export interface LanguageMetadata {
-  id: string;
-  name: string;
-  nativeName: string;
-  flag: string;
-  icon: string;
-  color: string;
-}
-
-// Supported languages with their metadata
-export const SUPPORTED_LANGUAGES: LanguageMetadata[] = [
-  {
-    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: string | null | undefined): LanguageMetadata | null {
-  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: string | null | undefined): string {
-  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: string | null | undefined): string {
-  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?: string | null): string {
-  if (!lang) return FALLBACK_LANGUAGE;
-  if (lang.includes('-')) return lang;
-  
-  const map: Record<string, string> = {
-    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/src/utils/loggerUtils.ts

@@ -1,153 +0,0 @@
-/**
- * Centralized logging utilities for consistent logging across the application
- */
-
-export enum LogLevel {
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-  NONE = 4
-}
-
-export interface LogContext {
-  component?: string;
-  method?: string;
-  userId?: string;
-  sessionId?: string;
-  requestId?: string;
-  [key: string]: unknown;
-}
-
-class Logger {
-  private level: LogLevel = LogLevel.INFO;
-  private isDevelopment: boolean = process.env.NODE_ENV === 'development';
-
-  setLevel(level: LogLevel): void {
-    this.level = level;
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    return level >= this.level;
-  }
-
-  private formatMessage(level: string, message: string, context?: LogContext): string {
-    const timestamp = new Date().toISOString();
-    const contextStr = context ? ` [${Object.entries(context).map(([k, v]) => `${k}:${v}`).join(', ')}]` : '';
-    return `[${timestamp}] ${level}${contextStr}: ${message}`;
-  }
-
-  debug(message: string, context?: LogContext, ...args: unknown[]): void {
-    if (this.shouldLog(LogLevel.DEBUG)) {
-      const formattedMessage = this.formatMessage('DEBUG', message, context);
-      if (this.isDevelopment) {
-        console.log(formattedMessage, ...args);
-      }
-    }
-  }
-
-  info(message: string, context?: LogContext, ...args: unknown[]): void {
-    if (this.shouldLog(LogLevel.INFO)) {
-      const formattedMessage = this.formatMessage('INFO', message, context);
-      console.log(formattedMessage, ...args);
-    }
-  }
-
-  warn(message: string, context?: LogContext, ...args: unknown[]): void {
-    if (this.shouldLog(LogLevel.WARN)) {
-      const formattedMessage = this.formatMessage('WARN', message, context);
-      console.warn(formattedMessage, ...args);
-    }
-  }
-
-  error(message: string, error?: Error | unknown, context?: LogContext, ...args: unknown[]): void {
-    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: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`🔐 ${message}`, { ...context, category: 'auth' }, ...args);
-  }
-
-  api(message: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`🌐 ${message}`, { ...context, category: 'api' }, ...args);
-  }
-
-  session(message: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`📱 ${message}`, { ...context, category: 'session' }, ...args);
-  }
-
-  user(message: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`👤 ${message}`, { ...context, category: 'user' }, ...args);
-  }
-
-  device(message: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`📱 ${message}`, { ...context, category: 'device' }, ...args);
-  }
-
-  payment(message: string, context?: LogContext, ...args: unknown[]): void {
-    this.info(`💳 ${message}`, { ...context, category: 'payment' }, ...args);
-  }
-
-  // Performance logging
-  performance(operation: string, duration: number, context?: LogContext): void {
-    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: string, error: Error, context?: LogContext): void {
-    this.error(message, error, { ...context, stack: error.stack });
-  }
-
-  // Group related log messages
-  group(label: string, fn: () => void): void {
-    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: string, context?: LogContext, ...args: unknown[]) => 
-  logger.auth(message, context, ...args);
-
-export const logApi = (message: string, context?: LogContext, ...args: unknown[]) => 
-  logger.api(message, context, ...args);
-
-export const logSession = (message: string, context?: LogContext, ...args: unknown[]) => 
-  logger.session(message, context, ...args);
-
-export const logUser = (message: string, context?: LogContext, ...args: unknown[]) => 
-  logger.user(message, context, ...args);
-
-export const logDevice = (message: string, context?: LogContext, ...args: unknown[]) => 
-  logger.device(message, context, ...args);
-
-export const logPayment = (message: string, context?: LogContext, ...args: unknown[]) => 
-  logger.payment(message, context, ...args);
-
-export const logError = (message: string, error?: Error | unknown, context?: LogContext, ...args: unknown[]) => 
-  logger.error(message, error, context, ...args);
-
-export const logPerformance = (operation: string, duration: number, context?: LogContext) => 
-  logger.performance(operation, duration, context); 

package/src/utils/platform.ts

@@ -1,117 +0,0 @@
-/**
- * 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.
- */
-
-export type PlatformOS = 'ios' | 'android' | 'web' | 'windows' | 'macos' | 'unknown';
-
-/**
- * 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(): PlatformOS {
-  // Check if React Native Platform is available globally (set by RN runtime)
-  // This avoids static imports while still detecting RN environment
-  const rnPlatform = (globalThis as any).__REACT_NATIVE_PLATFORM__;
-  if (rnPlatform) {
-    return rnPlatform as PlatformOS;
-  }
-
-  // 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: PlatformOS | null = null;
-
-/**
- * Get the current platform OS
- * Safe to call from any environment (web, Node.js, React Native)
- */
-export function getPlatformOS(): PlatformOS {
-  if (cachedPlatform === null) {
-    cachedPlatform = detectPlatform();
-  }
-  return cachedPlatform;
-}
-
-/**
- * Check if running on web platform (browser or Node.js)
- */
-export function isWeb(): boolean {
-  return getPlatformOS() === 'web';
-}
-
-/**
- * Check if running in a native app (iOS or Android)
- */
-export function isNative(): boolean {
-  const os = getPlatformOS();
-  return os === 'ios' || os === 'android';
-}
-
-/**
- * Check if running on iOS
- */
-export function isIOS(): boolean {
-  return getPlatformOS() === 'ios';
-}
-
-/**
- * Check if running on Android
- */
-export function isAndroid(): boolean {
-  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: PlatformOS): void {
-  cachedPlatform = os;
-  (globalThis as any).__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(): Promise<void> {
-  if (cachedPlatform !== null && cachedPlatform !== 'unknown') {
-    return; // Already initialized
-  }
-
-  try {
-    // Dynamic import to avoid bundler issues
-    const { Platform } = await import('react-native');
-    setPlatformOS(Platform.OS as PlatformOS);
-  } catch {
-    // react-native not available, use detected platform
-  }
-}

package/src/utils/platformInit.native.ts

@@ -1,13 +0,0 @@
-/**
- * Platform Initialization - React Native Version
- *
- * This file is resolved by Metro bundler for React Native apps.
- * It imports from react-native to set up platform detection.
- *
- * For web/Node.js, bundlers resolve platformInit.ts instead (no react-native import).
- */
-import { Platform } from 'react-native';
-import { setPlatformOS, type PlatformOS } from './platform';
-
-// Initialize platform from React Native's Platform module
-setPlatformOS(Platform.OS as PlatformOS);

package/src/utils/platformInit.ts

@@ -1,11 +0,0 @@
-/**
- * Platform Initialization - Web/Node.js Version
- *
- * This file is resolved by web bundlers (Vite, Webpack, etc.) and Node.js.
- * It does NOT import from react-native.
- *
- * For React Native, Metro resolves platformInit.native.ts instead.
- */
-
-// No initialization needed for web - platform detection happens automatically
-// via the isWeb() checks in platform.ts

package/src/utils/requestUtils.ts

@@ -1,237 +0,0 @@
-/**
- * Request utilities for HTTP clients
- * 
- * Provides reusable components for request deduplication, queuing, and logging
- */
-
-/**
- * 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
- * ```
- */
-export class RequestDeduplicator {
-  private pendingRequests = new Map<string, Promise<any>>();
-
-  /**
-   * 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<T>(
-    key: string,
-    requestFn: () => Promise<T>
-  ): Promise<T> {
-    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(): void {
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Get number of pending requests
-   */
-  size(): number {
-    return this.pendingRequests.size;
-  }
-}
-
-/**
- * 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'));
- * // ...
- * ```
- */
-export class RequestQueue {
-  private queue: Array<() => Promise<any>> = [];
-  private running = 0;
-  private maxConcurrent: number;
-  private maxQueueSize: number;
-
-  /**
-   * Create a new request queue
-   * @param maxConcurrent Maximum number of concurrent requests (default: 10)
-   * @param maxQueueSize Maximum queue size (default: 100)
-   */
-  constructor(maxConcurrent: number = 10, maxQueueSize: number = 100) {
-    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<T>(requestFn: () => Promise<T>): Promise<T> {
-    if (this.queue.length >= this.maxQueueSize) {
-      throw new Error('Request queue is full');
-    }
-
-    return new Promise<T>((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          const result = await requestFn();
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      });
-
-      this.process();
-    });
-  }
-
-  /**
-   * Process queued requests
-   */
-  private async process(): Promise<void> {
-    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(): void {
-    this.queue = [];
-  }
-
-  /**
-   * Get queue size
-   */
-  size(): number {
-    return this.queue.length;
-  }
-
-  /**
-   * Get number of currently running requests
-   */
-  runningCount(): number {
-    return this.running;
-  }
-}
-
-/** Log level type for SimpleLogger */
-export type LogLevel = 'none' | 'error' | 'warn' | 'info' | 'debug';
-
-/**
- * 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');
- * ```
- */
-export class SimpleLogger {
-  private enabled: boolean;
-  private level: LogLevel;
-  private prefix: string;
-
-  /**
-   * 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: boolean = false,
-    level: LogLevel = 'error',
-    prefix: string = ''
-  ) {
-    this.enabled = enabled;
-    this.level = level;
-    this.prefix = prefix;
-  }
-
-  private shouldLog(level: LogLevel): boolean {
-    if (!this.enabled || this.level === 'none') return false;
-    const levels: LogLevel[] = ['none', 'error', 'warn', 'info', 'debug'];
-    return levels.indexOf(level) <= levels.indexOf(this.level);
-  }
-
-  private formatMessage(...args: any[]): any[] {
-    return this.prefix ? [`[${this.prefix}]`, ...args] : args;
-  }
-
-  error(...args: any[]): void {
-    if (this.shouldLog('error')) {
-      console.error(...this.formatMessage(...args));
-    }
-  }
-
-  warn(...args: any[]): void {
-    if (this.shouldLog('warn')) {
-      console.warn(...this.formatMessage(...args));
-    }
-  }
-
-  info(...args: any[]): void {
-    if (this.shouldLog('info')) {
-      console.info(...this.formatMessage(...args));
-    }
-  }
-
-  debug(...args: any[]): void {
-    if (this.shouldLog('debug')) {
-      console.log(...this.formatMessage(...args));
-    }
-  }
-}
-