@oxyhq/services 5.25.0 → 5.26.1

package/src/lib/sonner.web.ts

@@ -0,0 +1,28 @@
+/**
+ * Sonner Toast - Web Implementation
+ *
+ * This file is resolved by web bundlers (Vite, Webpack, etc.)
+ * Only imports 'sonner' (web version), not 'sonner-native'
+ */
+import * as WebSonner from 'sonner';
+
+// Define proper types for the toast components
+interface ToastFunction {
+  (message: string, options?: Record<string, unknown>): void;
+  success: (message: string, options?: Record<string, unknown>) => void;
+  error: (message: string, options?: Record<string, unknown>) => void;
+  info: (message: string, options?: Record<string, unknown>) => void;
+  warning: (message: string, options?: Record<string, unknown>) => void;
+  loading: (message: string, options?: Record<string, unknown>) => void;
+}
+
+type ToasterComponent = (props?: Record<string, unknown>) => React.ReactElement | null;
+
+const { toast: webToast, Toaster: WebToaster } = WebSonner as {
+  toast: ToastFunction;
+  Toaster: ToasterComponent;
+};
+
+export const toast = webToast;
+export const Toaster = WebToaster;
+export type ToastT = typeof webToast;

package/src/models/session.ts

@@ -23,4 +23,8 @@ export interface SessionLoginResponse {
   deviceId: string;
   expiresAt: string;
   user: MinimalUserData;
+  /** JWT access token for API authentication */
+  accessToken?: string;
+  /** Refresh token for obtaining new access tokens */
+  refreshToken?: string;
 } 

package/src/shared/index.ts

@@ -0,0 +1,82 @@
+/**
+ * OxyServices Shared Module
+ *
+ * Platform-agnostic utilities and helpers that work everywhere:
+ * - Browser (Web, Expo Web)
+ * - React Native (iOS, Android)
+ * - Node.js (Backend)
+ *
+ * This module contains NO React Native or browser-specific dependencies.
+ *
+ * @module shared
+ *
+ * @example
+ * ```ts
+ * import { darkenColor, normalizeTheme, withRetry } from '@oxyhq/services/shared';
+ *
+ * const darkBlue = darkenColor('#0066FF', 0.3);
+ * const theme = normalizeTheme(userPreference);
+ * const data = await withRetry(() => fetchData(), { maxRetries: 3 });
+ * ```
+ */
+
+// Color utilities
+export {
+  darkenColor,
+  lightenColor,
+  hexToRgb,
+  rgbToHex,
+  withOpacity,
+  isLightColor,
+  getContrastTextColor,
+} from './utils/colorUtils';
+
+// Theme utilities
+export {
+  normalizeTheme,
+  normalizeColorScheme,
+  getOppositeTheme,
+  systemPrefersDarkMode,
+  getSystemColorScheme,
+} from './utils/themeUtils';
+export type { ThemeValue } from './utils/themeUtils';
+
+// Error utilities
+export {
+  HttpStatus,
+  getErrorStatus,
+  getErrorMessage,
+  isAlreadyRegisteredError,
+  isUnauthorizedError,
+  isForbiddenError,
+  isNotFoundError,
+  isRateLimitError,
+  isServerError,
+  isNetworkError,
+  isRetryableError,
+} from './utils/errorUtils';
+
+// Network utilities
+export {
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  createCircuitBreakerState,
+  calculateBackoffInterval,
+  recordFailure,
+  recordSuccess,
+  shouldAllowRequest,
+  delay,
+  withRetry,
+} from './utils/networkUtils';
+export type {
+  CircuitBreakerState,
+  CircuitBreakerConfig,
+} from './utils/networkUtils';
+
+// Debug utilities
+export {
+  isDev,
+  debugLog,
+  debugWarn,
+  debugError,
+  createDebugLogger,
+} from './utils/debugUtils';

package/src/shared/utils/colorUtils.ts

@@ -0,0 +1,155 @@
+/**
+ * Color Utility Functions
+ *
+ * Consolidated color manipulation utilities used across the OxyServices ecosystem.
+ * These functions work in any JavaScript environment (browser, Node.js, React Native).
+ *
+ * @module shared/utils/colorUtils
+ */
+
+/**
+ * Darkens a hex color by a specified factor.
+ *
+ * @param color - Hex color string (with or without #)
+ * @param factor - Amount to darken (0-1). Default: 0.6
+ * @returns Darkened hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * darkenColor('#FF0000', 0.5); // Returns a darker red
+ * darkenColor('FF0000', 0.3);  // Also works without #
+ * ```
+ */
+export const darkenColor = (color: string, factor: number = 0.6): string => {
+  const hex = color.replace('#', '');
+
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+
+  const newR = Math.max(0, Math.round(r * (1 - factor)));
+  const newG = Math.max(0, Math.round(g * (1 - factor)));
+  const newB = Math.max(0, Math.round(b * (1 - factor)));
+
+  return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+};
+
+/**
+ * Lightens a hex color by a specified factor.
+ *
+ * @param color - Hex color string (with or without #)
+ * @param factor - Amount to lighten (0-1). Default: 0.3
+ * @returns Lightened hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * lightenColor('#0000FF', 0.5); // Returns a lighter blue
+ * ```
+ */
+export const lightenColor = (color: string, factor: number = 0.3): string => {
+  const hex = color.replace('#', '');
+
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+
+  const newR = Math.min(255, Math.round(r + (255 - r) * factor));
+  const newG = Math.min(255, Math.round(g + (255 - g) * factor));
+  const newB = Math.min(255, Math.round(b + (255 - b) * factor));
+
+  return `#${newR.toString(16).padStart(2, '0')}${newG.toString(16).padStart(2, '0')}${newB.toString(16).padStart(2, '0')}`;
+};
+
+/**
+ * Converts a hex color to RGB values.
+ *
+ * @param hex - Hex color string (with or without #)
+ * @returns Object with r, g, b values (0-255)
+ *
+ * @example
+ * ```ts
+ * hexToRgb('#FF5733'); // { r: 255, g: 87, b: 51 }
+ * ```
+ */
+export const hexToRgb = (hex: string): { r: number; g: number; b: number } | null => {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result
+    ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16),
+      }
+    : null;
+};
+
+/**
+ * Converts RGB values to a hex color string.
+ *
+ * @param r - Red value (0-255)
+ * @param g - Green value (0-255)
+ * @param b - Blue value (0-255)
+ * @returns Hex color string with # prefix
+ *
+ * @example
+ * ```ts
+ * rgbToHex(255, 87, 51); // '#ff5733'
+ * ```
+ */
+export const rgbToHex = (r: number, g: number, b: number): string => {
+  return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+};
+
+/**
+ * Adjusts the opacity of a hex color, returning an rgba string.
+ *
+ * @param hex - Hex color string
+ * @param opacity - Opacity value (0-1)
+ * @returns RGBA color string
+ *
+ * @example
+ * ```ts
+ * withOpacity('#FF0000', 0.5); // 'rgba(255, 0, 0, 0.5)'
+ * ```
+ */
+export const withOpacity = (hex: string, opacity: number): string => {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return hex;
+  return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${opacity})`;
+};
+
+/**
+ * Checks if a color is considered "light" (for determining text contrast).
+ *
+ * @param hex - Hex color string
+ * @returns true if the color is light, false if dark
+ *
+ * @example
+ * ```ts
+ * isLightColor('#FFFFFF'); // true
+ * isLightColor('#000000'); // false
+ * ```
+ */
+export const isLightColor = (hex: string): boolean => {
+  const rgb = hexToRgb(hex);
+  if (!rgb) return true;
+
+  // Using relative luminance formula
+  const luminance = (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255;
+  return luminance > 0.5;
+};
+
+/**
+ * Gets a contrasting text color (black or white) for a given background color.
+ *
+ * @param backgroundColor - Hex color string of the background
+ * @returns '#000000' for light backgrounds, '#ffffff' for dark backgrounds
+ *
+ * @example
+ * ```ts
+ * getContrastTextColor('#FFFF00'); // '#000000' (black text on yellow)
+ * getContrastTextColor('#000080'); // '#ffffff' (white text on navy)
+ * ```
+ */
+export const getContrastTextColor = (backgroundColor: string): string => {
+  return isLightColor(backgroundColor) ? '#000000' : '#ffffff';
+};

package/src/shared/utils/debugUtils.ts

@@ -0,0 +1,73 @@
+/**
+ * Debug Utilities
+ *
+ * Provides safe logging functions that only output in development mode.
+ * All logs are stripped in production builds.
+ *
+ * @module shared/utils/debugUtils
+ */
+
+/* global __DEV__ */
+declare const __DEV__: boolean | undefined;
+
+/**
+ * Check if running in development mode
+ */
+export const isDev = (): boolean => {
+  return typeof __DEV__ !== 'undefined' && __DEV__;
+};
+
+/**
+ * Log a debug message (only in development)
+ * @param prefix - Log prefix (e.g., '[FedCM]')
+ * @param args - Arguments to log
+ */
+export const debugLog = (prefix: string, ...args: unknown[]): void => {
+  if (isDev()) {
+    console.log(prefix, ...args);
+  }
+};
+
+/**
+ * Log a debug warning (only in development)
+ * @param prefix - Log prefix
+ * @param args - Arguments to log
+ */
+export const debugWarn = (prefix: string, ...args: unknown[]): void => {
+  if (isDev()) {
+    console.warn(prefix, ...args);
+  }
+};
+
+/**
+ * Log a debug error (only in development)
+ * @param prefix - Log prefix
+ * @param args - Arguments to log
+ */
+export const debugError = (prefix: string, ...args: unknown[]): void => {
+  if (isDev()) {
+    console.error(prefix, ...args);
+  }
+};
+
+/**
+ * Create a namespaced debug logger
+ * @param namespace - Logger namespace (e.g., 'FedCM', 'PopupAuth')
+ * @returns Object with log, warn, error methods
+ *
+ * @example
+ * ```ts
+ * const debug = createDebugLogger('FedCM');
+ * debug.log('Starting authentication');
+ * debug.warn('Token expires soon');
+ * debug.error('Authentication failed', error);
+ * ```
+ */
+export const createDebugLogger = (namespace: string) => {
+  const prefix = `[${namespace}]`;
+  return {
+    log: (...args: unknown[]) => debugLog(prefix, ...args),
+    warn: (...args: unknown[]) => debugWarn(prefix, ...args),
+    error: (...args: unknown[]) => debugError(prefix, ...args),
+  };
+};

package/src/shared/utils/errorUtils.ts

@@ -0,0 +1,181 @@
+/**
+ * Error Utility Functions
+ *
+ * Consolidated error handling utilities for the OxyServices ecosystem.
+ * These functions help with common error patterns like checking HTTP status codes.
+ *
+ * @module shared/utils/errorUtils
+ */
+
+/**
+ * Common HTTP status codes used in error checking.
+ */
+export const HttpStatus = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+} as const;
+
+/**
+ * Extracts the HTTP status code from an error object.
+ *
+ * @param error - Any error object
+ * @returns The status code if found, undefined otherwise
+ */
+export const getErrorStatus = (error: unknown): number | undefined => {
+  if (!error || typeof error !== 'object') return undefined;
+
+  const err = error as Record<string, unknown>;
+
+  // Direct status property
+  if (typeof err.status === 'number') return err.status;
+
+  // Axios-style response.status
+  if (err.response && typeof err.response === 'object') {
+    const response = err.response as Record<string, unknown>;
+    if (typeof response.status === 'number') return response.status;
+  }
+
+  // statusCode property (some libraries use this)
+  if (typeof err.statusCode === 'number') return err.statusCode;
+
+  return undefined;
+};
+
+/**
+ * Extracts the error message from an error object.
+ *
+ * @param error - Any error object
+ * @param fallback - Fallback message if none found
+ * @returns The error message
+ */
+export const getErrorMessage = (error: unknown, fallback: string = 'An unknown error occurred'): string => {
+  if (!error) return fallback;
+
+  if (typeof error === 'string') return error;
+
+  if (error instanceof Error) return error.message;
+
+  if (typeof error === 'object') {
+    const err = error as Record<string, unknown>;
+
+    if (typeof err.message === 'string') return err.message;
+    if (typeof err.error === 'string') return err.error;
+
+    // Axios-style response.data.message
+    if (err.response && typeof err.response === 'object') {
+      const response = err.response as Record<string, unknown>;
+      if (response.data && typeof response.data === 'object') {
+        const data = response.data as Record<string, unknown>;
+        if (typeof data.message === 'string') return data.message;
+        if (typeof data.error === 'string') return data.error;
+      }
+    }
+  }
+
+  return fallback;
+};
+
+/**
+ * Check if an error indicates the user is already registered (HTTP 409 Conflict).
+ *
+ * The backend should always return HTTP 409 for duplicate registrations.
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 409 Conflict
+ */
+export const isAlreadyRegisteredError = (error: unknown): boolean => {
+  return getErrorStatus(error) === HttpStatus.CONFLICT;
+};
+
+/**
+ * Check if an error is an authentication error (HTTP 401).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 401 Unauthorized
+ */
+export const isUnauthorizedError = (error: unknown): boolean => {
+  return getErrorStatus(error) === HttpStatus.UNAUTHORIZED;
+};
+
+/**
+ * Check if an error is a forbidden error (HTTP 403).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 403 Forbidden
+ */
+export const isForbiddenError = (error: unknown): boolean => {
+  return getErrorStatus(error) === HttpStatus.FORBIDDEN;
+};
+
+/**
+ * Check if an error is a not found error (HTTP 404).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 404 Not Found
+ */
+export const isNotFoundError = (error: unknown): boolean => {
+  return getErrorStatus(error) === HttpStatus.NOT_FOUND;
+};
+
+/**
+ * Check if an error is a rate limit error (HTTP 429).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 429 Too Many Requests
+ */
+export const isRateLimitError = (error: unknown): boolean => {
+  return getErrorStatus(error) === HttpStatus.TOO_MANY_REQUESTS;
+};
+
+/**
+ * Check if an error is a server error (HTTP 5xx).
+ *
+ * @param error - Any error object
+ * @returns true if the error is a 5xx server error
+ */
+export const isServerError = (error: unknown): boolean => {
+  const status = getErrorStatus(error);
+  return status !== undefined && status >= 500 && status < 600;
+};
+
+/**
+ * Check if an error is a network error (no response received).
+ *
+ * @param error - Any error object
+ * @returns true if the error appears to be a network error
+ */
+export const isNetworkError = (error: unknown): boolean => {
+  if (!error || typeof error !== 'object') return false;
+
+  const err = error as Record<string, unknown>;
+
+  // Check for common network error indicators
+  if (err.name === 'NetworkError') return true;
+  if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') return true;
+
+  // Axios-style: has request but no response
+  if (err.request && !err.response) return true;
+
+  // Message-based detection
+  const message = getErrorMessage(error, '').toLowerCase();
+  return message.includes('network') || message.includes('connection') || message.includes('timeout');
+};
+
+/**
+ * Check if an error is retryable (network errors or 5xx server errors).
+ *
+ * @param error - Any error object
+ * @returns true if the request should be retried
+ */
+export const isRetryableError = (error: unknown): boolean => {
+  return isNetworkError(error) || isServerError(error) || isRateLimitError(error);
+};

package/src/shared/utils/index.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared Utility Functions
+ *
+ * Re-exports all shared utilities for convenient importing.
+ *
+ * @module shared/utils
+ */
+
+// Color utilities
+export {
+  darkenColor,
+  lightenColor,
+  hexToRgb,
+  rgbToHex,
+  withOpacity,
+  isLightColor,
+  getContrastTextColor,
+} from './colorUtils';
+
+// Theme utilities
+export {
+  normalizeTheme,
+  normalizeColorScheme,
+  getOppositeTheme,
+  systemPrefersDarkMode,
+  getSystemColorScheme,
+} from './themeUtils';
+export type { ThemeValue } from './themeUtils';
+
+// Error utilities
+export {
+  HttpStatus,
+  getErrorStatus,
+  getErrorMessage,
+  isAlreadyRegisteredError,
+  isUnauthorizedError,
+  isForbiddenError,
+  isNotFoundError,
+  isRateLimitError,
+  isServerError,
+  isNetworkError,
+  isRetryableError,
+} from './errorUtils';
+
+// Network utilities
+export {
+  DEFAULT_CIRCUIT_BREAKER_CONFIG,
+  createCircuitBreakerState,
+  calculateBackoffInterval,
+  recordFailure,
+  recordSuccess,
+  shouldAllowRequest,
+  delay,
+  withRetry,
+} from './networkUtils';
+export type {
+  CircuitBreakerState,
+  CircuitBreakerConfig,
+} from './networkUtils';