@umituz/react-native-ai-generation-content 1.17.229 → 1.17.230

package/src/features/upscaling/README.md

@@ -0,0 +1,247 @@
+# Upscaling
+
+Increase image resolution while maintaining quality using AI.
+
+## Features
+
+- Upscale images by 2x, 4x, or more
+- Maintain image quality and details
+- Remove noise and artifacts during upscaling
+- Support for various image formats
+
+## Installation
+
+This feature is part of `@umituz/react-native-ai-generation-content`.
+
+```bash
+npm install @umituz/react-native-ai-generation-content`
+```
+
+## Basic Usage
+
+### Using the Hook
+
+```tsx
+import { useUpscaleFeature } from '@umituz/react-native-ai-generation-content';
+import * as ImagePicker from 'react-native-image-picker';
+
+function UpscaleScreen() {
+  const [image, setImage] = useState<string | null>(null);
+
+  const feature = useUpscaleFeature({
+    config: {
+      defaultScaleFactor: 2,
+      onProcessingStart: () => console.log('Starting upscaling...'),
+      onProcessingComplete: (result) => console.log('Complete:', result),
+      onError: (error) => console.error('Error:', error),
+    },
+    onSelectImage: async () => {
+      const result = await ImagePicker.launchImageLibrary({ mediaType: 'photo' });
+      if (result.assets && result.assets[0].uri) {
+        const base64 = await convertToBase64(result.assets[0].uri);
+        setImage(base64);
+        return base64;
+      }
+      return null;
+    },
+    onSaveImage: async (imageUrl) => {
+      await saveToGallery(imageUrl);
+    },
+  });
+
+  return (
+    <View>
+      <PhotoUploadCard
+        image={image}
+        onSelectImage={feature.selectImage}
+        title="Select Image to Upscale"
+      />
+
+      <Button
+        title="Upscale Image"
+        onPress={feature.process}
+        disabled={!feature.isReady || feature.state.isProcessing}
+      />
+
+      {feature.state.isProcessing && (
+        <View>
+          <Text>Upscaling image...</Text>
+          <ProgressBar progress={feature.state.progress} />
+        </View>
+      )}
+
+      {feature.state.result && (
+        <Image source={{ uri: feature.state.result.imageUrl }} />
+      )}
+    </View>
+  );
+}
+```
+
+### Using the Unified AI Feature Screen
+
+```tsx
+import { AIFeatureScreen } from '@umituz/react-native-ai-generation-content';
+
+function App() {
+  return (
+    <AIFeatureScreen
+      featureId="upscaling"
+      userId="user-123"
+    />
+  );
+}
+```
+
+## Configuration Options
+
+### Feature Config
+
+```tsx
+interface UpscaleFeatureConfig {
+  defaultScaleFactor?: 2 | 4; // Scale factor (default: 2)
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: UpscaleResult) => void;
+  onError?: (error: string) => void;
+}
+```
+
+### Generation Options
+
+```tsx
+interface UpscaleOptions {
+  scaleFactor: 2 | 4;
+  enhance?: boolean; // Enhance image during upscaling
+  denoise?: boolean; // Remove noise during upscaling
+}
+```
+
+## Usage Flow
+
+1. Select **Image** - Choose an image to upscale
+2. Choose **Scale Factor** - Select 2x or 4x upscaling
+3. Tap **Upscale** - Start the upscaling process
+4. View Result - See the upscaled high-resolution image
+5. Save or Share - Save to gallery or share
+
+## Component Examples
+
+### Scale Factor Selector
+
+```tsx
+import { GridSelector } from '@umituz/react-native-ai-generation-content';
+
+const scaleOptions = [
+  { id: '2x', name: '2x', description: 'Double resolution' },
+  { id: '4x', name: '4x', description: 'Quadruple resolution' },
+];
+
+function MyScreen() {
+  const [scaleFactor, setScaleFactor] = useState('2x');
+
+  return (
+    <GridSelector
+      options={scaleOptions}
+      selectedOption={scaleFactor}
+      onSelectOption={setScaleFactor}
+    />
+  );
+}
+```
+
+### Before/After Comparison
+
+```tsx
+import { ResultDisplay } from '@umituz/react-native-ai-generation-content';
+
+{feature.state.result && originalImage && (
+  <View>
+    <Text>Before:</Text>
+    <Image source={{ uri: originalImage }} style={{ width: 200, height: 200 }} />
+
+    <Text>After (Upscaled):</Text>
+    <Image source={{ uri: feature.state.result.imageUrl }} style={{ width: 400, height: 400 }} />
+  </View>
+)}
+```
+
+## Advanced Usage
+
+### Custom Scale Factor
+
+```tsx
+const result = await feature.process({
+  scaleFactor: 4,
+  enhance: true,
+  denoise: true,
+});
+```
+
+### Progress Tracking
+
+```tsx
+const { state, process } = useUpscaleFeature({ ...config });
+
+useEffect(() => {
+  if (state.isProcessing) {
+    console.log(`Upscaling progress: ${state.progress}%`);
+  }
+}, [state.progress]);
+```
+
+## Use Cases
+
+### Enhancing Low-Resolution Photos
+
+```tsx
+// Upscale old photos for better quality
+const result = await feature.process({ scaleFactor: 2 });
+```
+
+### Preparing Images for Print
+
+```tsx
+// Upscale to print-ready resolution
+const result = await feature.process({ scaleFactor: 4 });
+```
+
+### Improving Image Quality
+
+```tsx
+// Upscale with enhancement and denoising
+const result = await feature.process({
+  scaleFactor: 2,
+  enhance: true,
+  denoise: true,
+});
+```
+
+## Best Practices
+
+1. **Start with 2x**: Try 2x first, then 4x if needed
+2. **Image Quality**: Higher quality source images produce better results
+3. **File Size**: Be aware that 4x upscaling significantly increases file size
+4. **Enhancement**: Use enhancement for better detail preservation
+5. **Testing**: Test different scale factors to find the best result
+
+## Error Handling
+
+```tsx
+const { state, process } = useUpscaleFeature({ ...config });
+
+useEffect(() => {
+  if (state.error) {
+    Alert.alert('Upscaling Failed', state.error);
+  }
+}, [state.error]);
+```
+
+## Related Features
+
+- [HD Touch Up](../hd-touch-up) - High-detail image enhancements
+- [Photo Restoration](../photo-restoration) - Restore old/blurry photos
+- [Image to Image](../image-to-image) - Transform images using AI
+
+## License
+
+MIT

package/src/infrastructure/config/README.md

@@ -0,0 +1,310 @@
+# Infrastructure Config
+
+Configuration management for the AI generation library.
+
+## Overview
+
+The config module provides centralized configuration management for all app services including network, auth, analytics, and more.
+
+## Features
+
+- Centralized service configuration
+- Dynamic configuration updates
+- Type-safe configuration objects
+- Environment-specific configs
+- Service availability checks
+
+## Usage
+
+### Initial Configuration
+
+```tsx
+import { configureAppServices } from '@umituz/react-native-ai-generation-content';
+
+// Configure all services at app startup
+configureAppServices({
+  networkService: {
+    baseUrl: 'https://api.example.com',
+    apiKey: process.env.API_KEY,
+    timeout: 30000,
+    headers: {
+      'X-Custom-Header': 'value',
+    },
+  },
+  creditService: {
+    checkCredits: async (userId, cost) => {
+      const user = await fetchUserCredits(userId);
+      return user.credits >= cost;
+    },
+    deductCredits: async (userId, cost) => {
+      await updateUserCredits(userId, -cost);
+    },
+    getCredits: async (userId) => {
+      const user = await fetchUserCredits(userId);
+      return user.credits;
+    },
+  },
+  paywallService: {
+    showPaywall: async () => {
+      // Show paywall screen or modal
+      return await navigateToPaywall();
+    },
+    isPaywallDismissed: async () => {
+      // Check if user has seen paywall
+      return await AsyncStorage.getItem('paywall_dismissed');
+    },
+  },
+  authService: {
+    getCurrentUser: async () => {
+      // Get current authenticated user
+      return await Auth.currentSession();
+    },
+    getToken: async () => {
+      // Get auth token
+      return await Auth.currentAuthenticatedUser();
+    },
+  },
+  analyticsService: {
+    trackEvent: async (event, properties) => {
+      // Track analytics event
+      await Analytics.track(event, properties);
+    },
+  },
+});
+```
+
+### Update Configuration
+
+```tsx
+import { updateAppServices } from '@umituz/react-native-ai-generation-content';
+
+// Update specific service configuration
+updateAppServices({
+  networkService: {
+    baseUrl: 'https://new-api.example.com',
+  },
+});
+```
+
+### Check Configuration
+
+```tsx
+import { isAppServicesConfigured, getAppServices } from '@umituz/react-native-ai-generation-content';
+
+if (!isAppServicesConfigured()) {
+  console.warn('App services not configured!');
+  // Handle unconfigured state
+}
+
+const services = getAppServices();
+console.log('Network base URL:', services.networkService?.baseUrl);
+```
+
+### Get Specific Service
+
+```tsx
+import {
+  getNetworkService,
+  getCreditService,
+  getPaywallService,
+  getAuthService,
+  getAnalyticsService,
+} from '@umituz/react-native-ai-generation-content';
+
+const networkService = getNetworkService();
+if (networkService) {
+  console.log('API URL:', networkService.baseUrl);
+}
+
+const creditService = getCreditService();
+if (creditService) {
+  const hasCredits = await creditService.checkCredits('user-123', 1);
+}
+```
+
+### Reset Configuration
+
+```tsx
+import { resetAppServices } from '@umituz/react-native-ai-generation-content';
+
+// Reset all services (useful for testing/logout)
+resetAppServices();
+```
+
+## Configuration Types
+
+### AppServicesConfig
+
+```tsx
+interface AppServicesConfig {
+  networkService?: INetworkService;
+  creditService?: ICreditService;
+  paywallService?: IPaywallService;
+  authService?: IAuthService;
+  analyticsService?: IAnalyticsService;
+}
+```
+
+### INetworkService
+
+```tsx
+interface INetworkService {
+  baseUrl: string;
+  apiKey?: string;
+  timeout?: number;
+  headers?: Record<string, string>;
+}
+```
+
+### ICreditService
+
+```tsx
+interface ICreditService {
+  checkCredits(userId: string, cost: number): Promise<boolean>;
+  deductCredits(userId: string, cost: number): Promise<void>;
+  getCredits(userId: string): Promise<number>;
+  addCredits(userId: string, amount: number): Promise<void>;
+}
+```
+
+### IPaywallService
+
+```tsx
+interface IPaywallService {
+  showPaywall(): Promise<boolean>;
+  isPaywallDismissed(): Promise<boolean>;
+  dismissPaywall(): Promise<void>;
+}
+```
+
+### IAuthService
+
+```tsx
+interface IAuthService {
+  getCurrentUser(): Promise<User | null>;
+  getToken(): Promise<string | null>;
+  isAuthenticated(): Promise<boolean>;
+}
+```
+
+### IAnalyticsService
+
+```tsx
+interface IAnalyticsService {
+  trackEvent(event: string, properties?: Record<string, any>): Promise<void>;
+  trackScreen(screenName: string): Promise<void>;
+  identifyUser(userId: string): Promise<void>;
+}
+```
+
+## Environment-Specific Configuration
+
+### Development
+
+```tsx
+if (__DEV__) {
+  configureAppServices({
+    networkService: {
+      baseUrl: 'https://dev-api.example.com',
+      apiKey: 'dev-key',
+    },
+    // ... other services
+  });
+}
+```
+
+### Production
+
+```tsx
+if (!__DEV__) {
+  configureAppServices({
+    networkService: {
+      baseUrl: 'https://api.example.com',
+      apiKey: process.env.PROD_API_KEY,
+    },
+    // ... other services
+  });
+}
+```
+
+### Dynamic Environment
+
+```tsx
+const getEnvConfig = () => {
+  const env = process.env.NODE_ENV || 'development';
+
+  switch (env) {
+    case 'production':
+      return {
+        baseUrl: 'https://api.example.com',
+      };
+    case 'staging':
+      return {
+        baseUrl: 'https://staging-api.example.com',
+      };
+    default:
+      return {
+        baseUrl: 'https://dev-api.example.com',
+      };
+  }
+};
+
+configureAppServices({
+  networkService: getEnvConfig(),
+});
+```
+
+## Best Practices
+
+1. **Configure Early**: Configure services at app startup
+2. **Type Safety**: Use proper types for all services
+3. **Error Handling**: Handle missing services gracefully
+4. **Environment Variables**: Use env vars for sensitive data
+5. **Validation**: Validate configuration before use
+
+## Error Handling
+
+```tsx
+import { isAppServicesConfigured } from '@umituz/react-native-ai-generation-content';
+
+function App() {
+  useEffect(() => {
+    if (!isAppServicesConfigured()) {
+      Alert.alert(
+        'Configuration Error',
+        'App services not configured. Please contact support.'
+      );
+    }
+  }, []);
+
+  // ...
+}
+```
+
+## Testing
+
+```tsx
+import { configureAppServices, resetAppServices } from '@umituz/react-native-ai-generation-content';
+
+beforeEach(() => {
+  configureAppServices({
+    networkService: {
+      baseUrl: 'https://test-api.example.com',
+    },
+  });
+});
+
+afterEach(() => {
+  resetAppServices();
+});
+```
+
+## Related
+
+- [Services](../services/) - AI generation services
+- [Middleware](../middleware/) - Request/response middleware
+- [Utils](../utils/) - Utility functions
+
+## License
+
+MIT