@umituz/react-native-ai-generation-content 1.12.2 → 1.12.3

package/src/domains/prompts/presentation/hooks/useAIServices.ts

@@ -0,0 +1,213 @@
+import { useState, useCallback } from 'react';
+import type { 
+  FaceSwapConfig
+} from '../../domain/entities/FaceSwapConfig';
+import type { 
+  PhotoRestorationConfig
+} from '../../domain/entities/PhotoRestorationConfig';
+import type { 
+  ImageEnhancementConfig
+} from '../../domain/entities/ImageEnhancementConfig';
+import type { 
+  StyleTransferConfig
+} from '../../domain/entities/StyleTransferConfig';
+import type { 
+  BackgroundRemovalConfig
+} from '../../domain/entities/BackgroundRemovalConfig';
+import type { 
+  TextGenerationConfig
+} from '../../domain/entities/TextGenerationConfig';
+import type { 
+  ColorizationConfig
+} from '../../domain/entities/ColorizationConfig';
+import type { 
+  IFaceSwapService,
+  IPhotoRestorationService,
+  IImageEnhancementService,
+  IStyleTransferService,
+  IBackgroundRemovalService,
+  ITextGenerationService,
+  IColorizationService
+} from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export type AIConfig = 
+  | { type: 'face-swap'; config: FaceSwapConfig }
+  | { type: 'photo-restoration'; config: PhotoRestorationConfig }
+  | { type: 'image-enhancement'; config: ImageEnhancementConfig }
+  | { type: 'style-transfer'; config: StyleTransferConfig }
+  | { type: 'background-removal'; config: BackgroundRemovalConfig }
+  | { type: 'text-generation'; config: TextGenerationConfig }
+  | { type: 'colorization'; config: ColorizationConfig };
+
+export interface UseAIServicesState {
+  generatedPrompt: GeneratedPrompt | null;
+  processing: boolean;
+  currentService: string | null;
+}
+
+export interface UseAIServicesActions {
+  processRequest: (aiConfig: AIConfig) => Promise<void>;
+  getAvailableStyles: (serviceType: string) => Promise<string[]>;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const useAIServices = (
+  services: {
+    faceSwap: IFaceSwapService;
+    photoRestoration: IPhotoRestorationService;
+    imageEnhancement: IImageEnhancementService;
+    styleTransfer: IStyleTransferService;
+    backgroundRemoval: IBackgroundRemovalService;
+    textGeneration: ITextGenerationService;
+    colorization: IColorizationService;
+  },
+  repositories: {
+    template: ITemplateRepository;
+    history: IPromptHistoryRepository;
+  }
+): UseAIServicesState & UseAIServicesActions => {
+  const {
+    data: generatedPrompt,
+    loading: processing,
+    error,
+    setError,
+    setData: setGeneratedPrompt,
+    clearError,
+  } = useAsyncState<GeneratedPrompt>(null);
+
+  const [currentService, setCurrentService] = useState<string | null>(null);
+
+  const processRequest = useCallback(async (aiConfig: AIConfig): Promise<void> => {
+    clearError();
+    setCurrentService(aiConfig.type);
+    
+    try {
+      let templateResult;
+      let promptResult;
+      
+      switch (aiConfig.type) {
+        case 'face-swap':
+          templateResult = await services.faceSwap.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'photo-restoration':
+          templateResult = await services.photoRestoration.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'image-enhancement':
+          templateResult = await services.imageEnhancement.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'style-transfer':
+          templateResult = await services.styleTransfer.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'background-removal':
+          templateResult = await services.backgroundRemoval.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'text-generation':
+          templateResult = await services.textGeneration.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        case 'colorization':
+          templateResult = await services.colorization.generateTemplate(aiConfig.config);
+          if (templateResult.success && templateResult.data) {
+            promptResult = await services.colorization.generatePrompt(templateResult.data, aiConfig.config);
+          }
+          break;
+          
+        default:
+          setError('Unknown AI service type');
+          return;
+      }
+      
+      if (!templateResult?.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+      
+      if (!promptResult?.success) {
+        setError('Failed to generate prompt');
+        return;
+      }
+      
+      const newPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: aiConfig.config as unknown as Record<string, unknown>,
+      });
+      
+      await repositories.history.save(newPrompt);
+      setGeneratedPrompt(newPrompt);
+      
+    } catch (error) {
+      setError('An unexpected error occurred');
+    } finally {
+      setCurrentService(null);
+    }
+  }, [services, repositories, setError, setGeneratedPrompt, clearError]);
+
+  const getAvailableStyles = useCallback(async (serviceType: string): Promise<string[]> => {
+    try {
+      switch (serviceType) {
+        case 'face-swap':
+          return await services.faceSwap.getAvailableStyles();
+        case 'style-transfer':
+          return await services.styleTransfer.getAvailableStyles();
+        default:
+          return [];
+      }
+    } catch (error) {
+      setError('Failed to load available styles');
+      return [];
+    }
+  }, [services, setError]);
+
+  const clearPrompt = useCallback(() => {
+    setGeneratedPrompt(null);
+    setCurrentService(null);
+    clearError();
+  }, [setGeneratedPrompt, clearError]);
+
+  const reset = useCallback(() => {
+    setGeneratedPrompt(null);
+    setCurrentService(null);
+    clearError();
+  }, [setGeneratedPrompt, clearError]);
+
+  return {
+    generatedPrompt,
+    processing,
+    currentService,
+    error,
+    processRequest,
+    getAvailableStyles,
+    clearPrompt,
+    reset,
+  } as UseAIServicesState & UseAIServicesActions;
+};

package/src/domains/prompts/presentation/hooks/useAsyncState.ts

@@ -0,0 +1,56 @@
+import { useState, useCallback } from 'react';
+
+export interface AsyncState<T> {
+  data: T | null;
+  loading: boolean;
+  error: string | null;
+}
+
+export interface AsyncActions<T> {
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  setData: (data: T | null) => void;
+  clearError: () => void;
+  reset: () => void;
+}
+
+export const useAsyncState = <T>(initialData: T | null = null): AsyncState<T> & AsyncActions<T> => {
+  const [state, setState] = useState<AsyncState<T>>({
+    data: initialData,
+    loading: false,
+    error: null,
+  });
+
+  const setLoading = useCallback((loading: boolean) => {
+    setState(prev => ({ ...prev, loading }));
+  }, []);
+
+  const setError = useCallback((error: string | null) => {
+    setState(prev => ({ ...prev, error, loading: false }));
+  }, []);
+
+  const setData = useCallback((data: T | null) => {
+    setState(prev => ({ ...prev, data, loading: false, error: null }));
+  }, []);
+
+  const clearError = useCallback(() => {
+    setState(prev => ({ ...prev, error: null }));
+  }, []);
+
+  const reset = useCallback(() => {
+    setState({
+      data: initialData,
+      loading: false,
+      error: null,
+    });
+  }, [initialData]);
+
+  return {
+    ...state,
+    setLoading,
+    setError,
+    setData,
+    clearError,
+    reset,
+  };
+};

package/src/domains/prompts/presentation/hooks/useFaceSwap.ts

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import type { FaceSwapConfig, FaceSwapGenerationResult } from '../../domain/entities/FaceSwapConfig';
+import type { IFaceSwapService } from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface UseFaceSwapState {
+  generatedPrompt: string | null;
+  lastResult: FaceSwapGenerationResult | null;
+}
+
+export interface UseFaceSwapActions {
+  generateFaceSwapPrompt: (config: FaceSwapConfig) => Promise<void>;
+  getAvailableStyles: () => Promise<string[]>;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const useFaceSwap = (
+  faceSwapService: IFaceSwapService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UseFaceSwapState & UseFaceSwapActions => {
+  const {
+    data: lastResult,
+    loading,
+    error,
+    setError,
+    setData: setResult,
+    clearError,
+  } = useAsyncState<FaceSwapGenerationResult>(null);
+
+  const generateFaceSwapPrompt = useCallback(async (config: FaceSwapConfig): Promise<void> => {
+    clearError();
+    
+    try {
+      const templateResult = await faceSwapService.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError(templateResult.success === false && templateResult.error === 'TEMPLATE_NOT_FOUND' ? 'Template not found' : 'Failed to generate template');
+        return;
+      }
+
+      const promptResult = await faceSwapService.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError(promptResult.success === false && promptResult.error === 'GENERATION_FAILED' ? 'Failed to generate prompt' : 'Generation failed');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: config as unknown as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const generationResult: FaceSwapGenerationResult = {
+        template: templateResult.data,
+        prompt: generatedPrompt,
+      };
+
+      setResult(generationResult);
+    } catch (error) {
+      setError('An unexpected error occurred');
+    }
+  }, [faceSwapService, historyRepository, setError, setResult, clearError]);
+
+  const getAvailableStyles = useCallback(async (): Promise<string[]> => {
+    try {
+      return await faceSwapService.getAvailableStyles();
+    } catch (error) {
+      setError('Failed to load available styles');
+      return [];
+    }
+  }, [faceSwapService, setError]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  return {
+    generatedPrompt: lastResult?.prompt.generatedText || null,
+    lastResult,
+    loading,
+    error,
+    generateFaceSwapPrompt,
+    getAvailableStyles,
+    clearPrompt,
+    reset,
+  } as UseFaceSwapState & UseFaceSwapActions;
+};

package/src/domains/prompts/presentation/hooks/useImageEnhancement.ts

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import type { ImageEnhancementConfig, EnhancementAdjustments } from '../../domain/entities/ImageEnhancementConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { IImageEnhancementService } from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface ImageEnhancementResult {
+  template: AIPromptTemplate;
+  config: ImageEnhancementConfig;
+  adjustments: EnhancementAdjustments;
+}
+
+export interface UseImageEnhancementState {
+  generatedPrompt: string | null;
+  lastResult: ImageEnhancementResult | null;
+  adjustments: EnhancementAdjustments | null;
+}
+
+export interface UseImageEnhancementActions {
+  enhanceImage: (config: ImageEnhancementConfig) => Promise<void>;
+  calculateAdjustments: (config: ImageEnhancementConfig) => EnhancementAdjustments;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const useImageEnhancement = (
+  service: IImageEnhancementService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UseImageEnhancementState & UseImageEnhancementActions => {
+  const {
+    data: lastResult,
+    setData: setResult,
+    clearError,
+    setError,
+  } = useAsyncState<ImageEnhancementResult>(null);
+
+  const enhanceImage = useCallback(async (config: ImageEnhancementConfig): Promise<void> => {
+    clearError();
+
+    try {
+      const templateResult = await service.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+
+      const promptResult = await service.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError('Failed to generate enhancement prompt');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: {} as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const enhancementResult: ImageEnhancementResult = {
+        template: templateResult.data,
+        config,
+        adjustments: service.calculateAdjustments(config),
+      };
+
+      setResult(enhancementResult);
+    } catch {
+      setError('An unexpected error occurred during image enhancement');
+    }
+  }, [service, historyRepository, setError, setResult, clearError]);
+
+  const calculateAdjustments = useCallback((config: ImageEnhancementConfig): EnhancementAdjustments => {
+    return service.calculateAdjustments(config);
+  }, [service]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  return {
+    generatedPrompt: null,
+    lastResult,
+    adjustments: lastResult?.adjustments || null,
+    enhanceImage,
+    calculateAdjustments,
+    clearPrompt,
+    reset,
+  };
+};

package/src/domains/prompts/presentation/hooks/usePhotoRestoration.ts

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import type { PhotoRestorationConfig } from '../../domain/entities/PhotoRestorationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { IPhotoRestorationService } from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface PhotoRestorationResult {
+  template: AIPromptTemplate;
+  config: PhotoRestorationConfig;
+  estimatedQuality: number;
+}
+
+export interface UsePhotoRestorationState {
+  generatedPrompt: string | null;
+  lastResult: PhotoRestorationResult | null;
+  estimatedQuality: number | null;
+}
+
+export interface UsePhotoRestorationActions {
+  restorePhoto: (config: PhotoRestorationConfig) => Promise<void>;
+  estimateQuality: (config: PhotoRestorationConfig) => number;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const usePhotoRestoration = (
+  service: IPhotoRestorationService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UsePhotoRestorationState & UsePhotoRestorationActions => {
+  const {
+    data: lastResult,
+    setData: setResult,
+    clearError,
+    setError,
+  } = useAsyncState<PhotoRestorationResult>(null);
+
+  const restorePhoto = useCallback(async (config: PhotoRestorationConfig): Promise<void> => {
+    clearError();
+
+    try {
+      const templateResult = await service.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+
+      const promptResult = await service.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError('Failed to generate restoration prompt');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: {} as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const restorationResult: PhotoRestorationResult = {
+        template: templateResult.data,
+        config,
+        estimatedQuality: service.estimateQuality(config),
+      };
+
+      setResult(restorationResult);
+    } catch {
+      setError('An unexpected error occurred during photo restoration');
+    }
+  }, [service, historyRepository, setError, setResult, clearError]);
+
+  const estimateQuality = useCallback((config: PhotoRestorationConfig): number => {
+    return service.estimateQuality(config);
+  }, [service]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  return {
+    generatedPrompt: null,
+    lastResult,
+    estimatedQuality: lastResult?.estimatedQuality || null,
+    restorePhoto,
+    estimateQuality,
+    clearPrompt,
+    reset,
+  };
+};