@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/hooks/useSessionSocket.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSessionSocket = useSessionSocket;
+const react_1 = require("react");
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+const sonner_1 = require("../../lib/sonner");
+const core_1 = require("@oxyhq/core");
+const core_2 = require("@oxyhq/core");
+const debug = (0, core_2.createDebugLogger)('SessionSocket');
+function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, getAccessToken, onRemoteSignOut, onSessionRemoved }) {
+    const socketRef = (0, react_1.useRef)(null);
+    // Store callbacks in refs to avoid reconnecting when they change
+    const refreshSessionsRef = (0, react_1.useRef)(refreshSessions);
+    const logoutRef = (0, react_1.useRef)(logout);
+    const clearSessionStateRef = (0, react_1.useRef)(clearSessionState);
+    const onRemoteSignOutRef = (0, react_1.useRef)(onRemoteSignOut);
+    const onSessionRemovedRef = (0, react_1.useRef)(onSessionRemoved);
+    const activeSessionIdRef = (0, react_1.useRef)(activeSessionId);
+    const currentDeviceIdRef = (0, react_1.useRef)(currentDeviceId);
+    const getAccessTokenRef = (0, react_1.useRef)(getAccessToken);
+    // Update refs when callbacks change
+    (0, react_1.useEffect)(() => {
+        refreshSessionsRef.current = refreshSessions;
+        logoutRef.current = logout;
+        clearSessionStateRef.current = clearSessionState;
+        onRemoteSignOutRef.current = onRemoteSignOut;
+        onSessionRemovedRef.current = onSessionRemoved;
+        activeSessionIdRef.current = activeSessionId;
+        currentDeviceIdRef.current = currentDeviceId;
+        getAccessTokenRef.current = getAccessToken;
+    }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId, getAccessToken]);
+    (0, react_1.useEffect)(() => {
+        if (!userId || !baseURL) {
+            // Clean up if userId or baseURL becomes invalid
+            if (socketRef.current) {
+                socketRef.current.disconnect();
+                socketRef.current = null;
+            }
+            return;
+        }
+        // Disconnect previous socket if switching users
+        if (socketRef.current) {
+            socketRef.current.disconnect();
+            socketRef.current = null;
+        }
+        // Connect with auth token; use callback so reconnections get a fresh token
+        socketRef.current = (0, socket_io_client_1.default)(baseURL, {
+            transports: ['websocket'],
+            auth: (cb) => {
+                const token = getAccessTokenRef.current();
+                cb({ token: token ?? '' });
+            },
+        });
+        const socket = socketRef.current;
+        // Server auto-joins the user to `user:<userId>` room on connection
+        const handleConnect = () => {
+            debug.log('Socket connected:', socket.id);
+        };
+        const handleSessionUpdate = async (data) => {
+            debug.log('Received session_update:', data);
+            const currentActiveSessionId = activeSessionIdRef.current;
+            const currentDeviceId = currentDeviceIdRef.current;
+            // Handle different event types
+            if (data.type === 'session_removed') {
+                // Track removed session
+                if (data.sessionId && onSessionRemovedRef.current) {
+                    onSessionRemovedRef.current(data.sessionId);
+                }
+                // If the removed sessionId matches the current activeSessionId, immediately clear state
+                if (data.sessionId === currentActiveSessionId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since session was already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after session_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, just refresh the sessions list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after session_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else if (data.type === 'device_removed') {
+                // Track all removed sessions from this device
+                if (data.sessionIds && onSessionRemovedRef.current) {
+                    for (const sessionId of data.sessionIds) {
+                        onSessionRemovedRef.current(sessionId);
+                    }
+                }
+                // If the removed deviceId matches the current device, immediately clear state
+                if (data.deviceId && data.deviceId === currentDeviceId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('This device has been removed. You have been signed out.');
+                    }
+                    // Use clearSessionState since sessions were already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after device_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, refresh sessions and device list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after device_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else if (data.type === 'sessions_removed') {
+                // Track all removed sessions
+                if (data.sessionIds && onSessionRemovedRef.current) {
+                    for (const sessionId of data.sessionIds) {
+                        onSessionRemovedRef.current(sessionId);
+                    }
+                }
+                // If the current activeSessionId is in the removed sessionIds list, immediately clear state
+                if (data.sessionIds && currentActiveSessionId && data.sessionIds.includes(currentActiveSessionId)) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since sessions were already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        if (__DEV__) {
+                            core_1.logger.error('Failed to clear session state after sessions_removed', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+                        }
+                    }
+                }
+                else {
+                    // Otherwise, refresh sessions list (with error handling)
+                    refreshSessionsRef.current().catch((error) => {
+                        // Silently handle errors from refresh - they're expected if sessions were removed
+                        if (__DEV__) {
+                            core_1.logger.debug('Failed to refresh sessions after sessions_removed', { component: 'useSessionSocket' }, error);
+                        }
+                    });
+                }
+            }
+            else {
+                // For other event types (e.g., session_created), refresh sessions (with error handling)
+                refreshSessionsRef.current().catch((error) => {
+                    // Log but don't throw - refresh errors shouldn't break the socket handler
+                    if (__DEV__) {
+                        core_1.logger.debug('Failed to refresh sessions after session_update', { component: 'useSessionSocket' }, error);
+                    }
+                });
+                // If the current session was logged out (legacy behavior), handle it specially
+                if (data.sessionId === currentActiveSessionId) {
+                    if (onRemoteSignOutRef.current) {
+                        onRemoteSignOutRef.current();
+                    }
+                    else {
+                        sonner_1.toast.info('You have been signed out remotely.');
+                    }
+                    // Use clearSessionState since session was already removed server-side
+                    // Await to ensure storage cleanup completes before continuing
+                    try {
+                        await clearSessionStateRef.current();
+                    }
+                    catch (error) {
+                        debug.error('Failed to clear session state after session_update:', error);
+                    }
+                }
+            }
+        };
+        socket.on('connect', handleConnect);
+        socket.on('session_update', handleSessionUpdate);
+        return () => {
+            socket.off('connect', handleConnect);
+            socket.off('session_update', handleSessionUpdate);
+            socket.disconnect();
+            socketRef.current = null;
+        };
+    }, [userId, baseURL]); // Only depend on userId and baseURL - callbacks are in refs
+}

package/src/ui/hooks/useSettingToggle.d.ts

@@ -0,0 +1,56 @@
+interface UseSettingToggleOptions {
+    /** Initial value of the setting */
+    initialValue: boolean;
+    /** Function to save the setting to the server */
+    onSave: (value: boolean) => Promise<void>;
+    /** Success message when saving */
+    successMessage?: string;
+    /** Error message when save fails */
+    errorMessage?: string;
+    /** Whether to revert on error (default: true) */
+    revertOnError?: boolean;
+    /** Whether to show success toast (default: false) */
+    showSuccessToast?: boolean;
+}
+interface UseSettingToggleReturn {
+    /** Current value */
+    value: boolean;
+    /** Whether the setting is being saved */
+    isSaving: boolean;
+    /** Toggle the setting (optimistic update with revert on error) */
+    toggle: () => Promise<void>;
+    /** Set the value directly */
+    setValue: (value: boolean) => void;
+}
+/**
+ * Hook for handling boolean toggle settings with optimistic updates.
+ * Automatically reverts to the previous value if the save fails.
+ *
+ * @example
+ * const { value, toggle, isSaving } = useSettingToggle({
+ *   initialValue: user.notificationsEnabled,
+ *   onSave: (value) => api.updateNotifications(value),
+ *   errorMessage: 'Failed to update notifications',
+ * });
+ *
+ * <Switch value={value} onValueChange={toggle} disabled={isSaving} />
+ */
+export declare function useSettingToggle(options: UseSettingToggleOptions): UseSettingToggleReturn;
+/**
+ * Hook for managing multiple toggle settings at once.
+ * Useful when you have several related boolean settings.
+ */
+export declare function useSettingToggles<T extends {
+    [K in keyof T]: boolean;
+}>(options: {
+    initialValues: T;
+    onSave: (key: keyof T, value: boolean) => Promise<void>;
+    errorMessage?: string | ((key: keyof T) => string);
+    revertOnError?: boolean;
+}): {
+    values: T;
+    savingKeys: Set<keyof T>;
+    toggle: (key: keyof T) => Promise<void>;
+    setValues: (values: Partial<T>) => void;
+};
+export default useSettingToggle;

package/src/ui/hooks/useSettingToggle.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSettingToggle = useSettingToggle;
+exports.useSettingToggles = useSettingToggles;
+const react_1 = require("react");
+const sonner_1 = require("../../lib/sonner");
+/**
+ * Hook for handling boolean toggle settings with optimistic updates.
+ * Automatically reverts to the previous value if the save fails.
+ *
+ * @example
+ * const { value, toggle, isSaving } = useSettingToggle({
+ *   initialValue: user.notificationsEnabled,
+ *   onSave: (value) => api.updateNotifications(value),
+ *   errorMessage: 'Failed to update notifications',
+ * });
+ *
+ * <Switch value={value} onValueChange={toggle} disabled={isSaving} />
+ */
+function useSettingToggle(options) {
+    const { initialValue, onSave, successMessage, errorMessage = 'Failed to save setting', revertOnError = true, showSuccessToast = false, } = options;
+    const [value, setValue] = (0, react_1.useState)(initialValue);
+    const [isSaving, setIsSaving] = (0, react_1.useState)(false);
+    // Update value when initialValue changes (e.g., from server)
+    (0, react_1.useEffect)(() => {
+        setValue(initialValue);
+    }, [initialValue]);
+    const toggle = (0, react_1.useCallback)(async () => {
+        const previousValue = value;
+        const newValue = !value;
+        // Optimistic update
+        setValue(newValue);
+        setIsSaving(true);
+        try {
+            await onSave(newValue);
+            if (showSuccessToast && successMessage) {
+                sonner_1.toast.success(successMessage);
+            }
+        }
+        catch (err) {
+            // Revert on error
+            if (revertOnError) {
+                setValue(previousValue);
+            }
+            sonner_1.toast.error(errorMessage || (err instanceof Error ? err.message : null) || 'An error occurred');
+        }
+        finally {
+            setIsSaving(false);
+        }
+    }, [value, onSave, successMessage, errorMessage, revertOnError, showSuccessToast]);
+    return { value, isSaving, toggle, setValue };
+}
+/**
+ * Hook for managing multiple toggle settings at once.
+ * Useful when you have several related boolean settings.
+ */
+function useSettingToggles(options) {
+    const { initialValues, onSave, errorMessage = 'Failed to save setting', revertOnError = true } = options;
+    const [values, setValues] = (0, react_1.useState)(initialValues);
+    const [savingKeys, setSavingKeys] = (0, react_1.useState)(new Set());
+    // Update values when initialValues change
+    (0, react_1.useEffect)(() => {
+        setValues(initialValues);
+    }, [initialValues]);
+    const toggle = (0, react_1.useCallback)(async (key) => {
+        const previousValue = values[key];
+        const newValue = !previousValue;
+        // Optimistic update
+        setValues(prev => ({ ...prev, [key]: newValue }));
+        setSavingKeys(prev => new Set(prev).add(key));
+        try {
+            await onSave(key, newValue);
+        }
+        catch (err) {
+            // Revert on error
+            if (revertOnError) {
+                setValues(prev => ({ ...prev, [key]: previousValue }));
+            }
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(key)
+                : errorMessage;
+            sonner_1.toast.error(message || (err instanceof Error ? err.message : null) || 'An error occurred');
+        }
+        finally {
+            setSavingKeys(prev => {
+                const next = new Set(prev);
+                next.delete(key);
+                return next;
+            });
+        }
+    }, [values, onSave, errorMessage, revertOnError]);
+    const setValuesExternal = (0, react_1.useCallback)((newValues) => {
+        setValues(prev => ({ ...prev, ...newValues }));
+    }, []);
+    return { values, savingKeys, toggle, setValues: setValuesExternal };
+}
+exports.default = useSettingToggle;

package/src/ui/hooks/useStorage.d.ts

@@ -0,0 +1,15 @@
+import type { ApiError } from '@oxyhq/core';
+import { type StorageInterface } from '../utils/storageHelpers';
+export interface UseStorageOptions {
+    onError?: (error: ApiError) => void;
+    logger?: (message: string, error?: unknown) => void;
+}
+export interface UseStorageResult {
+    storage: StorageInterface | null;
+    isReady: boolean;
+}
+/**
+ * Simple React hook that initializes platform-appropriate storage.
+ * Returns storage instance once ready, or null if initialization failed.
+ */
+export declare const useStorage: ({ onError, logger, }?: UseStorageOptions) => UseStorageResult;

package/src/ui/hooks/useStorage.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStorage = void 0;
+const react_1 = require("react");
+const storageHelpers_1 = require("../utils/storageHelpers");
+/**
+ * Simple React hook that initializes platform-appropriate storage.
+ * Returns storage instance once ready, or null if initialization failed.
+ */
+const useStorage = ({ onError, logger, } = {}) => {
+    const [storage, setStorage] = (0, react_1.useState)(null);
+    const initRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        // Prevent multiple initializations
+        if (initRef.current)
+            return;
+        initRef.current = (async () => {
+            try {
+                const storageInstance = await (0, storageHelpers_1.createPlatformStorage)();
+                setStorage(storageInstance);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Failed to initialize storage';
+                if (logger) {
+                    logger(message, err);
+                }
+                onError?.({
+                    message,
+                    code: 'STORAGE_INIT_ERROR',
+                    status: 500,
+                });
+            }
+        })();
+    }, [logger, onError]);
+    return {
+        storage,
+        isReady: storage !== null,
+    };
+};
+exports.useStorage = useStorage;

package/src/ui/hooks/useThemeColors.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Reusable hook to get theme colors based on current color scheme
+ * Returns the Colors object for the current theme (light or dark)
+ *
+ * @returns Colors object for the current color scheme
+ *
+ * @example
+ * ```tsx
+ * const colors = useThemeColors();
+ * <View style={{ backgroundColor: colors.background }}>
+ *   <Text style={{ color: colors.text }}>Hello</Text>
+ * </View>
+ * ```
+ */
+export declare const useThemeColors: () => {
+    text: string;
+    background: string;
+    inputBackground: string;
+    tint: string;
+    icon: string;
+    tabIconDefault: string;
+    tabIconSelected: string;
+    card: string;
+    border: string;
+    secondaryText: string;
+    avatarBackground: string;
+    avatarText: string;
+    sidebarBackground: string;
+    sidebarItemActiveBackground: string;
+    sidebarItemActiveText: string;
+    sidebarIconHome: string;
+    sidebarIconPersonalInfo: string;
+    sidebarIconSecurity: string;
+    sidebarIconPassword: string;
+    sidebarIconDevices: string;
+    sidebarIconData: string;
+    sidebarIconSharing: string;
+    sidebarIconFamily: string;
+    sidebarIconPayments: string;
+    sidebarIconStorage: string;
+    iconHome: string;
+    iconPrimary: string;
+    iconPersonalInfo: string;
+    iconSuccess: string;
+    iconSecurity: string;
+    iconData: string;
+    iconPurple: string;
+    iconSharing: string;
+    iconRed: string;
+    iconPayments: string;
+    iconGold: string;
+    iconStorage: string;
+    iconOrange: string;
+} | {
+    text: string;
+    background: string;
+    inputBackground: string;
+    tint: string;
+    icon: string;
+    tabIconDefault: string;
+    tabIconSelected: string;
+    card: string;
+    border: string;
+    secondaryText: string;
+    avatarBackground: string;
+    avatarText: string;
+    sidebarBackground: string;
+    sidebarItemActiveBackground: string;
+    sidebarItemActiveText: string;
+    sidebarIconHome: string;
+    sidebarIconPersonalInfo: string;
+    sidebarIconSecurity: string;
+    sidebarIconPassword: string;
+    sidebarIconDevices: string;
+    sidebarIconData: string;
+    sidebarIconSharing: string;
+    sidebarIconFamily: string;
+    sidebarIconPayments: string;
+    sidebarIconStorage: string;
+    iconHome: string;
+    iconPrimary: string;
+    iconPersonalInfo: string;
+    iconSuccess: string;
+    iconSecurity: string;
+    iconData: string;
+    iconPurple: string;
+    iconSharing: string;
+    iconRed: string;
+    iconPayments: string;
+    iconGold: string;
+    iconStorage: string;
+    iconOrange: string;
+};

package/src/ui/hooks/useThemeColors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThemeColors = void 0;
+const react_1 = require("react");
+const useColorScheme_1 = require("./useColorScheme");
+const theme_1 = require("../constants/theme");
+/**
+ * Reusable hook to get theme colors based on current color scheme
+ * Returns the Colors object for the current theme (light or dark)
+ *
+ * @returns Colors object for the current color scheme
+ *
+ * @example
+ * ```tsx
+ * const colors = useThemeColors();
+ * <View style={{ backgroundColor: colors.background }}>
+ *   <Text style={{ color: colors.text }}>Hello</Text>
+ * </View>
+ * ```
+ */
+const useThemeColors = () => {
+    const colorScheme = (0, useColorScheme_1.useColorScheme)();
+    return (0, react_1.useMemo)(() => {
+        return theme_1.Colors[colorScheme ?? 'light'];
+    }, [colorScheme]);
+};
+exports.useThemeColors = useThemeColors;

package/src/ui/hooks/useThemeStyles.d.ts

@@ -0,0 +1,44 @@
+import { Colors } from '../constants/theme';
+export interface ThemeStyles {
+    textColor: string;
+    backgroundColor: string;
+    secondaryBackgroundColor: string;
+    borderColor: string;
+    mutedTextColor: string;
+    isDarkTheme: boolean;
+    primaryColor: string;
+    dangerColor: string;
+    successColor: string;
+    colorScheme: 'light' | 'dark';
+    colors: typeof Colors.light;
+}
+/**
+ * Reusable hook for theme styles
+ * Replaces duplicated themeStyles useMemo pattern across multiple screens
+ *
+ * Provides consistent theme colors across all service screens:
+ * - Base colors (text, background, borders)
+ * - Semantic colors (primary, danger, success)
+ * - Theme-aware calculations
+ * - Normalized color scheme and Colors object
+ *
+ * @param theme - Theme string ('light' | 'dark')
+ * @param colorSchemeFromHook - Optional color scheme from useColorScheme() hook. If not provided, will call useColorScheme() internally.
+ * @returns ThemeStyles object with consistent color values
+ *
+ * @example
+ * ```tsx
+ * const themeStyles = useThemeStyles(theme);
+ * <View style={{ backgroundColor: themeStyles.backgroundColor }}>
+ *   <Text style={{ color: themeStyles.textColor }}>Hello</Text>
+ * </View>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const colorScheme = useColorScheme();
+ * const themeStyles = useThemeStyles(theme, colorScheme);
+ * const iconColor = themeStyles.colors.iconSecurity;
+ * ```
+ */
+export declare const useThemeStyles: (theme: string, colorSchemeFromHook?: string | null) => ThemeStyles;

package/src/ui/hooks/useThemeStyles.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useThemeStyles = void 0;
+const react_1 = require("react");
+const useColorScheme_1 = require("./useColorScheme");
+const theme_1 = require("../constants/theme");
+const themeUtils_1 = require("../utils/themeUtils");
+/**
+ * Reusable hook for theme styles
+ * Replaces duplicated themeStyles useMemo pattern across multiple screens
+ *
+ * Provides consistent theme colors across all service screens:
+ * - Base colors (text, background, borders)
+ * - Semantic colors (primary, danger, success)
+ * - Theme-aware calculations
+ * - Normalized color scheme and Colors object
+ *
+ * @param theme - Theme string ('light' | 'dark')
+ * @param colorSchemeFromHook - Optional color scheme from useColorScheme() hook. If not provided, will call useColorScheme() internally.
+ * @returns ThemeStyles object with consistent color values
+ *
+ * @example
+ * ```tsx
+ * const themeStyles = useThemeStyles(theme);
+ * <View style={{ backgroundColor: themeStyles.backgroundColor }}>
+ *   <Text style={{ color: themeStyles.textColor }}>Hello</Text>
+ * </View>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const colorScheme = useColorScheme();
+ * const themeStyles = useThemeStyles(theme, colorScheme);
+ * const iconColor = themeStyles.colors.iconSecurity;
+ * ```
+ */
+const useThemeStyles = (theme, colorSchemeFromHook) => {
+    const hookColorScheme = (0, useColorScheme_1.useColorScheme)();
+    const colorSchemeToUse = colorSchemeFromHook ?? hookColorScheme;
+    return (0, react_1.useMemo)(() => {
+        const colorScheme = (0, themeUtils_1.normalizeColorScheme)(colorSchemeToUse, theme);
+        const isDarkTheme = colorScheme === 'dark';
+        const colors = theme_1.Colors[colorScheme];
+        return {
+            // Base colors
+            textColor: isDarkTheme ? '#FFFFFF' : '#000000',
+            backgroundColor: isDarkTheme ? '#121212' : '#FFFFFF',
+            secondaryBackgroundColor: isDarkTheme ? '#222222' : '#F5F5F5',
+            borderColor: isDarkTheme ? '#444444' : '#E0E0E0',
+            mutedTextColor: '#8E8E93', // Same for both themes
+            // Semantic colors (consistent across themes)
+            primaryColor: '#007AFF',
+            dangerColor: '#FF3B30',
+            successColor: '#34C759',
+            // Theme flag
+            isDarkTheme,
+            // Normalized color scheme and theme colors
+            colorScheme,
+            colors,
+        };
+    }, [theme, colorSchemeToUse]);
+};
+exports.useThemeStyles = useThemeStyles;