@umituz/react-native-settings 4.20.56 → 4.20.57

package/README.md

@@ -1,16 +1,29 @@
 # @umituz/react-native-settings
 
-Settings management for React Native apps - user preferences, theme, language, notifications.
+Comprehensive settings management for React Native apps with modular domain-based architecture.
 
-## Features
+## 🌟 Features
 
+### Core Features
 - ✅ **User Settings Management** - Theme, language, notifications, privacy settings
 - ✅ **Zustand State Management** - Global settings state with Zustand
 - ✅ **Persistent Storage** - Uses @umituz/react-native-storage for persistence
-- ✅ **Settings Screens** - Pre-built settings screens (Settings, Appearance, Language Selection)
+- ✅ **Settings Screens** - Pre-built settings screens with modular architecture
 - ✅ **Setting Components** - Reusable setting item components
 - ✅ **Type-Safe** - Full TypeScript support
 
+### Domain Features
+- 🎨 **Appearance** - Theme customization (light/dark mode), custom color schemes
+- ℹ️ **About** - App information, version details, developer contact
+- ⚖️ **Legal** - Privacy policy, terms of service, legal documents
+- ⚠️ **Disclaimer** - Legal notices, warnings, important information
+- 💬 **Feedback** - User feedback forms, support resources
+- ❓ **FAQs** - Searchable frequently asked questions
+- ⭐ **Rating** - Star rating system with statistics
+- 🎥 **Video Tutorials** - Tutorial browser with featured content
+- ☁️ **Cloud Sync** - Sync status and management
+- 🛠️ **Dev Tools** - Development utilities (DEV mode only)
+
 ## Installation
 
 ```bash
@@ -373,13 +386,138 @@ This package follows **Domain-Driven Design (DDD)** principles:
 - ✅ **Error Boundaries**: Prevent crashes and provide graceful fallbacks
 - ✅ **Development Logs**: __DEV__ only logging for production safety
 
+## Domain Documentation
+
+Each domain has comprehensive documentation with usage examples, API references, and best practices:
+
+- **[About Domain Documentation](./src/domains/about/README.md)** - App information, version details, contact information
+- **[Appearance Domain Documentation](./src/domains/appearance/README.md)** - Theme management, dark mode, custom colors
+- **[Legal Domain Documentation](./src/domains/legal/README.md)** - Privacy policy, terms of service, legal documents
+- **[Disclaimer Domain Documentation](./src/domains/disclaimer/README.md)** - Legal notices, warnings, important information
+- **[Feedback Domain Documentation](./src/domains/feedback/README.md)** - Feedback forms, support resources
+- **[FAQs Domain Documentation](./src/domains/faqs/README.md)** - Searchable FAQ system
+- **[Rating Domain Documentation](./src/domains/rating/README.md)** - Star rating component
+- **[Video Tutorials Domain Documentation](./src/domains/video-tutorials/README.md)** - Video tutorial browser
+- **[Cloud Sync Domain Documentation](./src/domains/cloud-sync/README.md)** - Cloud sync status and management
+- **[Dev Domain Documentation](./src/domains/dev/README.md)** - Development utilities (DEV mode only)
+
+## Quick Start Examples
+
+### Complete Settings App
+
+```tsx
+import React from 'react';
+import { NavigationContainer } from '@react-navigation/native';
+import { createStackNavigator } from '@react-navigation/stack';
+import {
+  SettingsScreen,
+  AppearanceScreen,
+  AboutScreen,
+  LegalScreen,
+  FAQScreen,
+} from '@umituz/react-native-settings';
+
+const Stack = createStackNavigator();
+
+function App() {
+  return (
+    <NavigationContainer>
+      <Stack.Navigator>
+        <Stack.Screen name="Settings" component={SettingsScreen} />
+        <Stack.Screen name="Appearance" component={AppearanceScreen} />
+        <Stack.Screen name="About" component={AboutScreen} />
+        <Stack.Screen name="Legal" component={LegalScreen} />
+        <Stack.Screen name="FAQ" component={FAQScreen} />
+      </Stack.Navigator>
+    </NavigationContainer>
+  );
+}
+```
+
+### Custom Settings Screen
+
+```tsx
+import { SettingsSection, SettingsItemCard } from '@umituz/react-native-settings';
+
+function CustomSettingsScreen() {
+  return (
+    <ScreenLayout>
+      <SettingsSection title="PREFERENCES">
+        <SettingsItemCard
+          icon="moon-outline"
+          title="Dark Mode"
+          showSwitch={true}
+          switchValue={isDarkMode}
+          onSwitchChange={setDarkMode}
+        />
+        <SettingsItemCard
+          icon="globe-outline"
+          title="Language"
+          description="English"
+          onPress={() => {}}
+        />
+      </SettingsSection>
+
+      <SettingsSection title="SUPPORT">
+        <SettingsItemCard
+          icon="help-circle-outline"
+          title="Help & FAQs"
+          onPress={() => navigation.navigate('FAQ')}
+        />
+        <SettingsItemCard
+          icon="chatbubble-outline"
+          title="Send Feedback"
+          onPress={() => navigation.navigate('Feedback')}
+        />
+      </SettingsSection>
+    </ScreenLayout>
+  );
+}
+```
+
+## Project Structure
+
+```
+src/
+├── domains/                    # Feature domains (DDD architecture)
+│   ├── about/                  # App information & about
+│   ├── appearance/             # Theme & appearance settings
+│   ├── legal/                  # Privacy policy & terms
+│   ├── disclaimer/             # Legal disclaimers
+│   ├── feedback/               # User feedback system
+│   ├── faqs/                   # FAQ management
+│   ├── rating/                 # Rating system
+│   ├── video-tutorials/        # Video tutorials
+│   ├── cloud-sync/             # Cloud synchronization
+│   └── dev/                    # Development tools
+├── presentation/               # Shared UI components
+│   ├── screens/               # Settings screens
+│   ├── components/            # Reusable components
+│   └── hooks/                 # Shared hooks
+├── application/               # Application logic
+├── infrastructure/            # External dependencies
+└── index.ts                   # Main exports
+```
+
 ## Version History
 
+- **v4.20.56**: Added comprehensive domain documentation with README files for each feature
+- **v4.20.55**: Enhanced domain structure with individual README documentation
+- **v4.20.54**: Refactored package structure - split files under 200 lines
 - **v2.2.0**: Major refactor - removed hardcoded text, improved architecture, added comprehensive tests
 - **v2.1.0**: Enhanced component structure and TypeScript support
 - **v2.0.0**: Breaking changes - removed LanguageSelectionScreen, improved API
 - **v1.x.x**: Initial releases with basic settings functionality
 
+## Contributing
+
+When contributing to this package:
+1. Follow the domain-driven design structure
+2. Keep files under 200 lines
+3. Add tests for new features
+4. Update relevant domain README
+5. Follow TypeScript best practices
+
 ## License
 
 MIT
@@ -388,3 +526,7 @@ MIT
 
 Ümit UZ <umit@umituz.com>
 
+---
+
+**Made with ❤️ for the React Native community**
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-settings",
-  "version": "4.20.56",
+  "version": "4.20.57",
   "description": "Complete settings hub for React Native apps - consolidated package with settings, about, legal, appearance, feedback, FAQs, and rating",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -93,7 +93,6 @@
     "expo-file-system": "^19.0.21",
     "expo-haptics": "^15.0.8",
     "expo-image": "^3.0.11",
-    "expo-linear-gradient": "^15.0.8",
     "expo-localization": "^17.0.8",
     "expo-notifications": "^0.32.15",
     "expo-sharing": "^14.0.8",

package/src/application/README.md

@@ -0,0 +1,322 @@
+# Application Layer
+
+The application layer defines the core business logic, interfaces, and types for the settings domain following Domain-Driven Design (DDD) principles.
+
+## Architecture
+
+The application layer serves as the bridge between the presentation and infrastructure layers, defining the contracts that both layers must follow.
+
+```
+application/
+└── ports/
+    └── ISettingsRepository.ts    # Repository interface and types
+```
+
+## Core Types
+
+### UserSettings
+
+The main data structure for user settings.
+
+```typescript
+interface UserSettings {
+  userId: string;                      // Unique user identifier
+  theme: 'light' | 'dark' | 'auto';    // Theme preference
+  language: string;                    // Language code (e.g., 'en-US')
+  notificationsEnabled: boolean;       // Master notification switch
+  emailNotifications: boolean;          // Email notification preference
+  pushNotifications: boolean;           // Push notification preference
+  soundEnabled: boolean;               // Sound effects toggle
+  vibrationEnabled: boolean;           // Haptic feedback toggle
+  privacyMode: boolean;                // Privacy/screen shield mode
+  disclaimerAccepted: boolean;         // Legal disclaimer acceptance
+  updatedAt: Date;                     // Last update timestamp
+}
+```
+
+### SettingsResult
+
+Result wrapper for settings operations.
+
+```typescript
+interface SettingsResult<T> {
+  success: boolean;                    // Operation success flag
+  data?: T;                            // Result data (if successful)
+  error?: SettingsError;               // Error details (if failed)
+}
+```
+
+### SettingsError
+
+Error structure for settings operations.
+
+```typescript
+interface SettingsError {
+  code: string;                        // Error code for identification
+  message: string;                     // Human-readable error message
+}
+```
+
+## Repository Interface
+
+### ISettingsRepository
+
+The contract that all settings repository implementations must follow.
+
+```typescript
+interface ISettingsRepository {
+  /**
+   * Retrieve settings for a user
+   * @param userId - Unique user identifier
+   * @returns Promise resolving to settings result
+   */
+  getSettings(userId: string): Promise<SettingsResult<UserSettings>>;
+
+  /**
+   * Save settings for a user
+   * @param settings - Complete settings object to save
+   * @returns Promise resolving to operation result
+   */
+  saveSettings(settings: UserSettings): Promise<SettingsResult<void>>;
+
+  /**
+   * Delete settings for a user
+   * @param userId - Unique user identifier
+   * @returns Promise resolving to operation result
+   */
+  deleteSettings(userId: string): Promise<SettingsResult<void>>;
+}
+```
+
+## Usage Examples
+
+### Defining a Custom Repository
+
+```typescript
+import type { ISettingsRepository, UserSettings, SettingsResult } from '@umituz/react-native-settings';
+
+class CustomSettingsRepository implements ISettingsRepository {
+  async getSettings(userId: string): Promise<SettingsResult<UserSettings>> {
+    try {
+      // Your custom implementation
+      const settings = await fetchFromAPI(userId);
+      return { success: true, data: settings };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: 'FETCH_FAILED',
+          message: error.message,
+        },
+      };
+    }
+  }
+
+  async saveSettings(settings: UserSettings): Promise<SettingsResult<void>> {
+    // Your implementation
+  }
+
+  async deleteSettings(userId: string): Promise<SettingsResult<void>> {
+    // Your implementation
+  }
+}
+```
+
+### Using Repository Interface
+
+```typescript
+import type { ISettingsRepository } from '@umituz/react-native-settings';
+
+class SettingsService {
+  constructor(private repository: ISettingsRepository) {}
+
+  async getUserSettings(userId: string) {
+    const result = await this.repository.getSettings(userId);
+
+    if (!result.success) {
+      throw new Error(result.error?.message);
+    }
+
+    return result.data;
+  }
+
+  async updateUserPreferences(userId: string, preferences: Partial<UserSettings>) {
+    const current = await this.getUserSettings(userId);
+    const updated = { ...current, ...preferences, updatedAt: new Date() };
+
+    return this.repository.saveSettings(updated);
+  }
+}
+```
+
+### Testing with Mock Repository
+
+```typescript
+class MockSettingsRepository implements ISettingsRepository {
+  private settings: Map<string, UserSettings> = new Map();
+
+  async getSettings(userId: string): Promise<SettingsResult<UserSettings>> {
+    const settings = this.settings.get(userId);
+    if (!settings) {
+      return {
+        success: false,
+        error: { code: 'NOT_FOUND', message: 'Settings not found' },
+      };
+    }
+    return { success: true, data: settings };
+  }
+
+  async saveSettings(settings: UserSettings): Promise<SettingsResult<void>> {
+    this.settings.set(settings.userId, settings);
+    return { success: true };
+  }
+
+  async deleteSettings(userId: string): Promise<SettingsResult<void>> {
+    this.settings.delete(userId);
+    return { success: true };
+  }
+}
+
+// Usage in tests
+const mockRepo = new MockSettingsRepository();
+const service = new SettingsService(mockRepo);
+
+await service.updateUserPreferences('user123', { theme: 'dark' });
+```
+
+## Default Settings
+
+When no settings exist, the following defaults are used:
+
+```typescript
+const defaultSettings: UserSettings = {
+  userId: '',
+  theme: 'auto',                      // Follow system theme
+  language: 'en-US',                  // English (US)
+  notificationsEnabled: true,         // Notifications on
+  emailNotifications: true,           // Email notifications on
+  pushNotifications: true,            // Push notifications on
+  soundEnabled: true,                 // Sound on
+  vibrationEnabled: true,             // Vibration on
+  privacyMode: false,                 // Privacy mode off
+  disclaimerAccepted: false,          // Disclaimer not accepted
+  updatedAt: new Date(),
+};
+```
+
+## Error Handling
+
+### Error Codes
+
+Common error codes used throughout the application:
+
+| Code | Description |
+|------|-------------|
+| `GET_SETTINGS_FAILED` | Failed to retrieve settings |
+| `SAVE_SETTINGS_FAILED` | Failed to save settings |
+| `DELETE_SETTINGS_FAILED` | Failed to delete settings |
+| `INVALID_USER_ID` | Invalid user identifier |
+| `VALIDATION_ERROR` | Settings validation failed |
+| `NOT_FOUND` | Settings not found for user |
+| `STORAGE_ERROR` | Underlying storage error |
+| `NETWORK_ERROR` | Network communication error |
+
+### Error Handling Pattern
+
+```typescript
+async function handleSettingsOperation<T>(
+  operation: () => Promise<SettingsResult<T>>
+): Promise<T> {
+  const result = await operation();
+
+  if (!result.success) {
+    throw new SettingsError(
+      result.error?.code || 'UNKNOWN_ERROR',
+      result.error?.message || 'An unknown error occurred'
+    );
+  }
+
+  return result.data!;
+}
+
+// Usage
+try {
+  const settings = await handleSettingsOperation(() =>
+    repository.getSettings(userId)
+  );
+} catch (error) {
+  if (error instanceof SettingsError) {
+    console.error(`[${error.code}] ${error.message}`);
+  }
+}
+```
+
+## Best Practices
+
+1. **Type Safety**: Always use the defined interfaces
+2. **Error Handling**: Check `success` flag before accessing data
+3. **Immutability**: Return new objects, don't mutate existing ones
+4. **Validation**: Validate settings before saving
+5. **Default Values**: Always provide sensible defaults
+6. **Timestamp Updates**: Update `updatedAt` on every change
+7. **Partial Updates**: Support partial updates when possible
+8. **Repository Pattern**: Always program to the interface, not implementation
+
+## Testing Utilities
+
+```typescript
+// Test factory for creating test settings
+function createTestSettings(overrides?: Partial<UserSettings>): UserSettings {
+  return {
+    userId: 'test-user',
+    theme: 'light',
+    language: 'en-US',
+    notificationsEnabled: true,
+    emailNotifications: true,
+    pushNotifications: true,
+    soundEnabled: true,
+    vibrationEnabled: true,
+    privacyMode: false,
+    disclaimerAccepted: true,
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+// Test factory for creating error results
+function createErrorResult<T>(
+  code: string,
+  message: string
+): SettingsResult<T> {
+  return {
+    success: false,
+    error: { code, message },
+  };
+}
+
+// Test factory for creating success results
+function createSuccessResult<T>(data?: T): SettingsResult<T> {
+  return {
+    success: true,
+    data,
+  };
+}
+```
+
+## Integration Points
+
+The application layer integrates with:
+
+- **Presentation Layer**: Provides interfaces for UI components
+- **Infrastructure Layer**: Defines contracts for storage implementation
+- **Domain Layer**: Contains business logic and entities
+
+## Related
+
+- **Infrastructure**: Repository implementations
+- **Presentation Hooks**: React hooks for UI
+- **Type Definitions**: Complete type definitions
+
+## License
+
+MIT