@oxyhq/services 5.13.3 → 5.13.10

package/src/ui/screens/SearchSettingsScreen.tsx

@@ -0,0 +1,219 @@
+import React, { useState, useCallback, useMemo, useEffect } from 'react';
+import {
+    View,
+    Text,
+    TouchableOpacity,
+    StyleSheet,
+    ScrollView,
+    Switch,
+    ActivityIndicator,
+} from 'react-native';
+import type { BaseScreenProps } from '../navigation/types';
+import { useOxy } from '../context/OxyContext';
+import { toast } from '../../lib/sonner';
+import { Header, Section, GroupedSection } from '../components';
+import { useI18n } from '../hooks/useI18n';
+
+const SearchSettingsScreen: React.FC<BaseScreenProps> = ({
+    onClose,
+    theme,
+    goBack,
+}) => {
+    const { oxyServices, user } = useOxy();
+    const { t } = useI18n();
+    const [safeSearch, setSafeSearch] = useState(false);
+    const [searchPersonalization, setSearchPersonalization] = useState(true);
+    const [isLoading, setIsLoading] = useState(true);
+    const [isSaving, setIsSaving] = useState(false);
+
+    // Load settings
+    useEffect(() => {
+        const loadSettings = async () => {
+            try {
+                setIsLoading(true);
+                if (user?.id && oxyServices) {
+                    // Load from user's privacy settings
+                    const userData = await oxyServices.getCurrentUser();
+                    const privacySettings = (userData as any)?.privacySettings || {};
+                    
+                    // SafeSearch is typically stored in privacySettings.autoFilter or a separate field
+                    setSafeSearch(privacySettings.autoFilter ?? false);
+                    setSearchPersonalization(privacySettings.dataSharing ?? true);
+                }
+            } catch (error) {
+                console.error('Failed to load search settings:', error);
+            } finally {
+                setIsLoading(false);
+            }
+        };
+
+        loadSettings();
+    }, [user?.id, oxyServices]);
+
+    const handleSafeSearchToggle = useCallback(async (value: boolean) => {
+        try {
+            setIsSaving(true);
+            setSafeSearch(value);
+            
+            if (user?.id && oxyServices) {
+                // Update privacy settings
+                await oxyServices.updateProfile({
+                    privacySettings: {
+                        autoFilter: value,
+                    },
+                });
+                toast.success(t('searchSettings.safeSearch.updated') || 'SafeSearch setting updated');
+            }
+        } catch (error) {
+            console.error('Failed to update SafeSearch:', error);
+            toast.error(t('searchSettings.safeSearch.error') || 'Failed to update SafeSearch');
+            setSafeSearch(!value); // Revert on error
+        } finally {
+            setIsSaving(false);
+        }
+    }, [user?.id, oxyServices, t]);
+
+    const handlePersonalizationToggle = useCallback(async (value: boolean) => {
+        try {
+            setIsSaving(true);
+            setSearchPersonalization(value);
+            
+            if (user?.id && oxyServices) {
+                // Update privacy settings
+                await oxyServices.updateProfile({
+                    privacySettings: {
+                        dataSharing: value,
+                    },
+                });
+                toast.success(t('searchSettings.personalization.updated') || 'Search personalization updated');
+            }
+        } catch (error) {
+            console.error('Failed to update personalization:', error);
+            toast.error(t('searchSettings.personalization.error') || 'Failed to update personalization');
+            setSearchPersonalization(!value); // Revert on error
+        } finally {
+            setIsSaving(false);
+        }
+    }, [user?.id, oxyServices, t]);
+
+    const themeStyles = useMemo(() => {
+        const isDarkTheme = theme === 'dark';
+        return {
+            textColor: isDarkTheme ? '#FFFFFF' : '#000000',
+            backgroundColor: isDarkTheme ? '#121212' : '#FFFFFF',
+            secondaryBackgroundColor: isDarkTheme ? '#222222' : '#F5F5F5',
+            borderColor: isDarkTheme ? '#444444' : '#E0E0E0',
+        };
+    }, [theme]);
+
+    if (isLoading) {
+        return (
+            <View style={[styles.container, { backgroundColor: themeStyles.backgroundColor }]}>
+                <Header
+                    title={t('searchSettings.title') || 'Search Settings'}
+                    theme={theme}
+                    onBack={goBack || onClose}
+                    variant="minimal"
+                    elevation="subtle"
+                />
+                <View style={styles.loadingContainer}>
+                    <ActivityIndicator size="large" color={themeStyles.textColor} />
+                </View>
+            </View>
+        );
+    }
+
+    return (
+        <View style={[styles.container, { backgroundColor: themeStyles.backgroundColor }]}>
+            <Header
+                title={t('searchSettings.title') || 'Search Settings'}
+                theme={theme}
+                onBack={goBack || onClose}
+                variant="minimal"
+                elevation="subtle"
+            />
+
+            <ScrollView style={styles.content}>
+                {/* SafeSearch */}
+                <Section title={t('searchSettings.safeSearch.title') || 'SafeSearch'} theme={theme} isFirst={true}>
+                    <View style={[styles.settingRow, { borderBottomColor: themeStyles.borderColor }]}>
+                        <View style={styles.settingInfo}>
+                            <Text style={[styles.settingTitle, { color: themeStyles.textColor }]}>
+                                {t('searchSettings.safeSearch.label') || 'Enable SafeSearch'}
+                            </Text>
+                            <Text style={[styles.settingDescription, { color: themeStyles.textColor }]}>
+                                {t('searchSettings.safeSearch.description') || 'Filter out explicit content from search results'}
+                            </Text>
+                        </View>
+                        <Switch
+                            value={safeSearch}
+                            onValueChange={handleSafeSearchToggle}
+                            disabled={isSaving}
+                            trackColor={{ false: '#767577', true: '#d169e5' }}
+                            thumbColor={safeSearch ? '#fff' : '#f4f3f4'}
+                        />
+                    </View>
+                </Section>
+
+                {/* Search Personalization */}
+                <Section title={t('searchSettings.personalization.title') || 'Search Personalization'} theme={theme}>
+                    <View style={[styles.settingRow, { borderBottomColor: themeStyles.borderColor }]}>
+                        <View style={styles.settingInfo}>
+                            <Text style={[styles.settingTitle, { color: themeStyles.textColor }]}>
+                                {t('searchSettings.personalization.label') || 'Personalized Search'}
+                            </Text>
+                            <Text style={[styles.settingDescription, { color: themeStyles.textColor }]}>
+                                {t('searchSettings.personalization.description') || 'Use your activity to improve search results'}
+                            </Text>
+                        </View>
+                        <Switch
+                            value={searchPersonalization}
+                            onValueChange={handlePersonalizationToggle}
+                            disabled={isSaving}
+                            trackColor={{ false: '#767577', true: '#d169e5' }}
+                            thumbColor={searchPersonalization ? '#fff' : '#f4f3f4'}
+                        />
+                    </View>
+                </Section>
+            </ScrollView>
+        </View>
+    );
+};
+
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+    },
+    content: {
+        flex: 1,
+        padding: 16,
+    },
+    loadingContainer: {
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    settingRow: {
+        flexDirection: 'row',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        paddingVertical: 16,
+        borderBottomWidth: 1,
+    },
+    settingInfo: {
+        flex: 1,
+        marginRight: 16,
+    },
+    settingTitle: {
+        fontSize: 16,
+        fontWeight: '500',
+        marginBottom: 4,
+    },
+    settingDescription: {
+        fontSize: 14,
+        opacity: 0.7,
+    },
+});
+
+export default React.memo(SearchSettingsScreen);
+

package/src/ui/screens/SignInScreen.tsx

@@ -42,10 +42,7 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
 
     // Username validation using core services with caching
     const validateUsername = useCallback(async (usernameToValidate: string) => {
-        if (__DEV__) console.log('🔍 Validating username:', usernameToValidate);
-
         if (!usernameToValidate || usernameToValidate.length < 3) {
-            if (__DEV__) console.log('❌ Username too short');
             setValidationStatus('invalid');
             setErrorMessage('Username must be at least 3 characters.');
             return false;
@@ -53,7 +50,7 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
 
         // Safety check for oxyServices
         if (!oxyServices || typeof oxyServices.getProfileByUsername !== 'function') {
-            console.error('🚨 oxyServices not available or getProfileByUsername not found');
+            console.error('oxyServices not available or getProfileByUsername not found');
             setValidationStatus('invalid');
             setErrorMessage('Service unavailable. Please try again.');
             return false;
@@ -62,62 +59,51 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
         const offlineDetected = typeof navigator !== 'undefined' && navigator.onLine === false;
 
         if (offlineDetected) {
-            if (__DEV__) console.log('⚠️ Offline detected, skipping username validation');
             setValidationStatus('invalid');
             setErrorMessage('No connection. Check your internet connection and try again.');
             return false;
         }
 
-        if (__DEV__) console.log('🔄 Validating username with API...');
         setIsValidating(true);
         setValidationStatus('validating');
 
         try {
             // Check if username exists
             const profile = await oxyServices.getProfileByUsername(usernameToValidate);
-            if (__DEV__) console.log('📋 Profile response:', profile);
 
-            if (profile && profile.username) {
+            // Handle case where profile might be wrapped in a data property (defensive check)
+            const userProfile = (profile as any)?.data || profile;
+
+            if (userProfile?.username) {
                 const profileData = {
-                    displayName: profile.name?.full || profile.name?.first || profile.username,
-                    name: profile.username,
-                    avatar: profile.avatar,
-                    id: profile.id
+                    displayName: userProfile.name?.full || userProfile.name?.first || userProfile.username,
+                    name: userProfile.username,
+                    avatar: userProfile.avatar,
+                    id: userProfile.id
                 };
 
-                if (__DEV__) console.log('✅ Username is valid:', profileData);
                 setUserProfile(profileData);
-                
+
                 // Check if this account is already signed in
-                const profileUserId = profile.id?.toString();
+                const profileUserId = userProfile.id?.toString();
                 const existing = sessions?.find(s => {
                     const sessionUserId = s.userId?.toString();
                     return sessionUserId === profileUserId;
                 });
-                
-                if (existing) {
-                    setExistingSession(existing);
-                    if (__DEV__) console.log('✅ Account already signed in:', existing);
-                } else {
-                    setExistingSession(null);
-                }
-                
+
+                setExistingSession(existing || null);
                 setValidationStatus('valid');
                 setErrorMessage('');
 
                 return true;
-            } else {
-                if (__DEV__) console.log('❌ Username not found');
-                setValidationStatus('invalid');
-                setErrorMessage('Username not found.');
-                return false;
             }
-        } catch (error: any) {
-            if (__DEV__) console.log('🚨 Validation error:', error);
 
+            setValidationStatus('invalid');
+            setErrorMessage('Username not found.');
+            return false;
+        } catch (error: any) {
             // If user not found (404), username doesn't exist
             if (error?.status === 404 || error?.code === 'USER_NOT_FOUND') {
-                console.log('❌ Username not found (404)');
                 setValidationStatus('invalid');
                 setErrorMessage('Username not found.');
                 return false;
@@ -147,7 +133,6 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
 
     // Input change handlers
     const handleUsernameChange = useCallback((text: string) => {
-        console.log('🔄 SignInScreen handleUsernameChange called:', text);
         setUsername(text);
         if (errorMessage) setErrorMessage('');
         setValidationStatus('idle');
@@ -183,7 +168,7 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
 
     const handleContinueWithExistingAccount = useCallback(async () => {
         if (!existingSession) return;
-        
+
         try {
             setErrorMessage('');
             await switchSession(existingSession.sessionId);
@@ -206,7 +191,7 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
             setErrorMessage('Please enter a valid username first.');
             return;
         }
-        
+
         try {
             setErrorMessage('');
             const user = await login(username, password);
@@ -238,7 +223,6 @@ const SignInScreen: React.FC<BaseScreenProps> = ({
     const handleComplete = useCallback(async (stepData: any[]) => {
         // The sign-in is handled by the password step component
         // This callback is here for interface compatibility
-        if (__DEV__) console.log('Sign-in flow completed');
     }, []);
 
     // Step data for the reusable component

package/src/utils/asyncUtils.ts

@@ -204,6 +204,7 @@ export async function withTimeout<T>(
 export function createAsyncCache<T>(
   ttl: number = 5 * 60 * 1000 // 5 minutes default
 ) {
+  // Re-export from centralized cache utility
   const cache = new TTLCache<T>(ttl);
   registerCacheForCleanup(cache);
   

package/src/utils/cache.ts

@@ -251,10 +251,10 @@ export function unregisterCacheFromCleanup(cache: TTLCache<any>): void {
 }
 
 /**
- * Stop all cache cleanup intervals
- * Useful for tests to prevent Jest from hanging
+ * Stop all cleanup intervals (useful for testing)
+ * This will clear the interval and unregister all caches
  */
-export function stopAllCacheCleanup(): void {
+export function stopAllCleanupIntervals(): void {
   if (cleanupInterval) {
     clearInterval(cleanupInterval);
     cleanupInterval = null;

package/src/utils/index.ts

@@ -5,7 +5,7 @@ export type { DeviceFingerprint, StoredDeviceInfo } from './deviceManager';
 export { RequestDeduplicator, RequestQueue, SimpleLogger } from './requestUtils';
 
 // Cache utilities
-export { TTLCache, createCache, registerCacheForCleanup, unregisterCacheFromCleanup, stopAllCacheCleanup } from './cache';
+export { TTLCache, createCache, registerCacheForCleanup, unregisterCacheFromCleanup } from './cache';
 export type { CacheStats } from './cache';
 
 // Session utilities