@oxyhq/core 1.0.0

package/dist/esm/shared/utils/colorUtils.js

@@ -0,0 +1,143 @@
+/**
+ * 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, factor = 0.6) => {
+    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, factor = 0.3) => {
+    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) => {
+    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, g, b) => {
+    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, opacity) => {
+    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) => {
+    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) => {
+    return isLightColor(backgroundColor) ? '#000000' : '#ffffff';
+};

package/dist/esm/shared/utils/debugUtils.js

@@ -0,0 +1,65 @@
+/**
+ * Debug Utilities
+ *
+ * Provides safe logging functions that only output in development mode.
+ * All logs are stripped in production builds.
+ *
+ * @module shared/utils/debugUtils
+ */
+/**
+ * Check if running in development mode
+ */
+export const isDev = () => {
+    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, ...args) => {
+    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, ...args) => {
+    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, ...args) => {
+    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) => {
+    const prefix = `[${namespace}]`;
+    return {
+        log: (...args) => debugLog(prefix, ...args),
+        warn: (...args) => debugWarn(prefix, ...args),
+        error: (...args) => debugError(prefix, ...args),
+    };
+};

package/dist/esm/shared/utils/errorUtils.js

@@ -0,0 +1,170 @@
+/**
+ * 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,
+};
+/**
+ * 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) => {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const err = error;
+    // 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;
+        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, fallback = 'An unknown error occurred') => {
+    if (!error)
+        return fallback;
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'object') {
+        const err = error;
+        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;
+            if (response.data && typeof response.data === 'object') {
+                const data = response.data;
+                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) => {
+    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) => {
+    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) => {
+    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) => {
+    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) => {
+    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) => {
+    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) => {
+    if (!error || typeof error !== 'object')
+        return false;
+    const err = error;
+    // 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) => {
+    return isNetworkError(error) || isServerError(error) || isRateLimitError(error);
+};

package/dist/esm/shared/utils/index.js

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

package/dist/esm/shared/utils/networkUtils.js

@@ -0,0 +1,173 @@
+/**
+ * Network Utility Functions
+ *
+ * Consolidated network utilities including circuit breaker pattern
+ * and exponential backoff for resilient API calls.
+ *
+ * @module shared/utils/networkUtils
+ */
+/**
+ * Default circuit breaker configuration.
+ */
+export const DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+    baseInterval: 10000,
+    maxInterval: 60000,
+    maxFailures: 5,
+    recoveryTimeout: 30000,
+};
+/**
+ * Creates initial circuit breaker state.
+ *
+ * @param config - Optional custom configuration
+ * @returns Initial circuit breaker state
+ *
+ * @example
+ * ```ts
+ * const state = createCircuitBreakerState({ maxFailures: 3 });
+ * ```
+ */
+export const createCircuitBreakerState = (config = {}) => {
+    const { baseInterval, maxInterval, maxFailures } = {
+        ...DEFAULT_CIRCUIT_BREAKER_CONFIG,
+        ...config,
+    };
+    return {
+        consecutiveFailures: 0,
+        currentInterval: baseInterval,
+        baseInterval,
+        maxInterval,
+        maxFailures,
+        isOpen: false,
+    };
+};
+/**
+ * Calculates next interval using exponential backoff.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Next interval in milliseconds
+ *
+ * @example
+ * ```ts
+ * const nextInterval = calculateBackoffInterval(state);
+ * await delay(nextInterval);
+ * ```
+ */
+export const calculateBackoffInterval = (state) => {
+    const { consecutiveFailures, baseInterval, maxInterval } = state;
+    if (consecutiveFailures === 0)
+        return baseInterval;
+    const backoffMultiplier = Math.min(Math.pow(2, consecutiveFailures - 1), maxInterval / baseInterval);
+    return Math.min(baseInterval * backoffMultiplier, maxInterval);
+};
+/**
+ * Records a failure and updates circuit breaker state.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Updated state after recording failure
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await apiCall();
+ *   state = recordSuccess(state);
+ * } catch (error) {
+ *   state = recordFailure(state);
+ * }
+ * ```
+ */
+export const recordFailure = (state) => {
+    const newFailures = state.consecutiveFailures + 1;
+    const newInterval = calculateBackoffInterval({
+        ...state,
+        consecutiveFailures: newFailures,
+    });
+    const shouldOpenCircuit = newFailures >= state.maxFailures;
+    const finalInterval = shouldOpenCircuit ? state.maxInterval : newInterval;
+    return {
+        ...state,
+        consecutiveFailures: newFailures,
+        currentInterval: finalInterval,
+        isOpen: shouldOpenCircuit,
+        openedAt: shouldOpenCircuit ? Date.now() : state.openedAt,
+    };
+};
+/**
+ * Records a success and resets circuit breaker state.
+ *
+ * @param state - Current circuit breaker state
+ * @returns Reset state after successful request
+ */
+export const recordSuccess = (state) => {
+    return {
+        ...state,
+        consecutiveFailures: 0,
+        currentInterval: state.baseInterval,
+        isOpen: false,
+        openedAt: undefined,
+    };
+};
+/**
+ * Checks if the circuit breaker should allow a request.
+ *
+ * When the circuit is open, it will only allow requests after
+ * the recovery timeout has passed (half-open state).
+ *
+ * @param state - Current circuit breaker state
+ * @param recoveryTimeout - Time to wait before allowing recovery attempts
+ * @returns true if request should be allowed
+ */
+export const shouldAllowRequest = (state, recoveryTimeout = DEFAULT_CIRCUIT_BREAKER_CONFIG.recoveryTimeout) => {
+    if (!state.isOpen)
+        return true;
+    if (!state.openedAt)
+        return true;
+    const timeSinceOpen = Date.now() - state.openedAt;
+    return timeSinceOpen >= recoveryTimeout;
+};
+/**
+ * Delays execution for a specified duration.
+ *
+ * @param ms - Milliseconds to delay
+ * @returns Promise that resolves after the delay
+ *
+ * @example
+ * ```ts
+ * await delay(1000); // Wait 1 second
+ * ```
+ */
+export const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Executes a function with exponential backoff retry.
+ *
+ * @param fn - Async function to execute
+ * @param options - Retry options
+ * @returns Result of the function
+ * @throws Last error if all retries fail
+ *
+ * @example
+ * ```ts
+ * const result = await withRetry(
+ *   () => fetchData(),
+ *   { maxRetries: 3, baseDelay: 1000 }
+ * );
+ * ```
+ */
+export const withRetry = async (fn, options = {}) => {
+    const { maxRetries = 3, baseDelay = 1000, maxDelay = 30000, shouldRetry = () => true, onRetry, } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxRetries || !shouldRetry(error)) {
+                throw error;
+            }
+            const delayMs = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+            onRetry?.(error, attempt + 1);
+            await delay(delayMs);
+        }
+    }
+    throw lastError;
+};

package/dist/esm/shared/utils/themeUtils.js

@@ -0,0 +1,98 @@
+/**
+ * Theme Utility Functions
+ *
+ * Consolidated theme utilities for normalizing and handling color schemes
+ * across the OxyServices ecosystem.
+ *
+ * @module shared/utils/themeUtils
+ */
+/**
+ * Normalizes a theme value to ensure it's always 'light' or 'dark'.
+ *
+ * @param theme - Theme value (may be 'light' | 'dark' | string | undefined)
+ * @returns Normalized 'light' | 'dark' theme (defaults to 'light')
+ *
+ * @example
+ * ```ts
+ * normalizeTheme('dark');     // 'dark'
+ * normalizeTheme('light');    // 'light'
+ * normalizeTheme('unknown');  // 'light'
+ * normalizeTheme(undefined);  // 'light'
+ * normalizeTheme(null);       // 'light'
+ * ```
+ */
+export const normalizeTheme = (theme) => theme === 'light' || theme === 'dark' ? theme : 'light';
+/**
+ * Normalizes a color scheme value with optional fallback chain.
+ *
+ * Handles null/undefined cases from React Native's useColorScheme() hook
+ * with a proper fallback chain.
+ *
+ * @param colorScheme - The color scheme from useColorScheme() hook (may be null/undefined)
+ * @param theme - Optional theme prop as fallback
+ * @returns Normalized 'light' | 'dark' color scheme
+ *
+ * @example
+ * ```ts
+ * // In a React Native component:
+ * const systemScheme = useColorScheme(); // might be null
+ * const colorScheme = normalizeColorScheme(systemScheme, props.theme);
+ *
+ * normalizeColorScheme('dark', 'light');      // 'dark'
+ * normalizeColorScheme(null, 'dark');         // 'dark'
+ * normalizeColorScheme(undefined, undefined); // 'light'
+ * ```
+ */
+export const normalizeColorScheme = (colorScheme, theme) => {
+    if (colorScheme === 'light' || colorScheme === 'dark') {
+        return colorScheme;
+    }
+    if (theme === 'light' || theme === 'dark') {
+        return theme;
+    }
+    return 'light';
+};
+/**
+ * Gets the opposite theme value.
+ *
+ * @param theme - Current theme value
+ * @returns The opposite theme ('light' → 'dark', 'dark' → 'light')
+ *
+ * @example
+ * ```ts
+ * getOppositeTheme('light'); // 'dark'
+ * getOppositeTheme('dark');  // 'light'
+ * ```
+ */
+export const getOppositeTheme = (theme) => theme === 'light' ? 'dark' : 'light';
+/**
+ * Checks if the system prefers dark mode.
+ *
+ * This function only works in browser environments.
+ * Returns false in non-browser environments (Node.js, React Native).
+ *
+ * @returns true if system prefers dark mode, false otherwise
+ *
+ * @example
+ * ```ts
+ * if (systemPrefersDarkMode()) {
+ *   setTheme('dark');
+ * }
+ * ```
+ */
+export const systemPrefersDarkMode = () => {
+    if (typeof window === 'undefined')
+        return false;
+    return window.matchMedia?.('(prefers-color-scheme: dark)').matches ?? false;
+};
+/**
+ * Gets the system's preferred color scheme.
+ *
+ * @returns 'dark' if system prefers dark mode, 'light' otherwise
+ *
+ * @example
+ * ```ts
+ * const theme = getSystemColorScheme();
+ * ```
+ */
+export const getSystemColorScheme = () => systemPrefersDarkMode() ? 'dark' : 'light';