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

package/src/domains/prompts/infrastructure/services/TextGenerationService.ts

@@ -0,0 +1,241 @@
+import type { ITextGenerationService } from '../../domain/repositories/IAIPromptServices';
+import type {
+  TextGenerationConfig,
+} from '../../domain/entities/TextGenerationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult } from '../../domain/entities/types';
+import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import {
+  validateTextGenerationConfig,
+  getTokenCount,
+  getTemperature,
+  getTopP
+} from '../../domain/entities/TextGenerationConfig';
+import { PromptGenerationService } from '../services/PromptGenerationService';
+
+const createTextGenerationBaseTemplate = (config?: {
+  promptType?: string;
+  tone?: string;
+  language?: string;
+}): string => {
+  const {
+    promptType = 'general',
+    tone = 'professional',
+    language = 'English'
+  } = config || {};
+
+  return `
+You are an expert text generation specialist.
+This is a TEXT GENERATION task with specific requirements.
+
+GENERATION OBJECTIVES:
+- Generate ${promptType} content with ${tone} tone
+- Write in ${language} language
+- Follow provided context and constraints
+- Deliver high-quality, appropriate content
+
+CONTENT STANDARDS:
+- Clear, coherent, and well-structured text
+- Appropriate for the specified tone and purpose
+- Natural language flow and readability
+- Relevant and informative content
+
+STYLE REQUIREMENTS:
+- Maintain ${tone} tone throughout
+- Use appropriate vocabulary and expressions
+- Follow conventions for ${promptType} content
+- Adapt complexity to intended audience
+
+LANGUAGE REQUIREMENTS:
+- Write fluently in ${language}
+- Use proper grammar and syntax
+- Consider cultural and regional variations
+- Maintain consistency in language usage
+
+SAFETY AND QUALITY:
+- Generate appropriate, non-offensive content
+- Avoid harmful or misleading information
+- Ensure factual accuracy when applicable
+- Respect copyright and intellectual property
+
+OUTPUT:
+Professional ${promptType} content in ${language},
+written with ${tone} tone,
+meeting all specified requirements.
+  `.trim();
+};
+
+export class TextGenerationService implements ITextGenerationService {
+  private promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  async generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return {
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: 'Invalid text generation configuration'
+        };
+      }
+
+      const template = this.createTextGenerationTemplate(config);
+      return { success: true, data: template };
+    } catch (error) {
+      return {
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate text template'
+      };
+    }
+  }
+
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: TextGenerationConfig
+  ): Promise<AIPromptResult<string>> {
+    const parameters = this.getGenerationParameters(config);
+    const variables = {
+      promptType: config.promptType,
+      tone: config.tone,
+      length: config.length,
+      language: config.language,
+      context: config.context || '',
+      keywords: config.keywords?.join(', ') || '',
+      ...parameters,
+    };
+
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  validateConfig(config: TextGenerationConfig): boolean {
+    return validateTextGenerationConfig(config);
+  }
+
+  estimateTokens(config: TextGenerationConfig): number {
+    return getTokenCount(config.length);
+  }
+
+  getGenerationParameters(config: TextGenerationConfig): Record<string, number> {
+    return {
+      temperature: getTemperature(config.promptType, config.tone),
+      maxTokens: this.estimateTokens(config),
+      topP: getTopP(config.promptType),
+      frequencyPenalty: config.tone === 'formal' ? 0.3 : 0.1,
+      presencePenalty: config.promptType === 'creative' ? 0.2 : 0.1,
+    };
+  }
+
+  private createTextGenerationTemplate(config: TextGenerationConfig): AIPromptTemplate {
+    const templateId = `text-generation-${config.promptType}`;
+
+    const baseTemplate = createTextGenerationBaseTemplate({
+      promptType: config.promptType,
+      tone: config.tone,
+      language: config.language,
+    });
+
+    return createAIPromptTemplate({
+      id: templateId,
+      name: `Text Generation: ${config.promptType}`,
+      description: `Generate ${config.promptType} content in ${config.language}`,
+      category: 'text-generation',
+      template: `${baseTemplate}
+
+GENERATION PARAMETERS:
+- Prompt Type: ${config.promptType}
+- Tone: ${config.tone}
+- Length: ${config.length}
+- Language: ${config.language}
+- Estimated Tokens: ${this.estimateTokens(config)}
+
+${config.context ? `CONTEXT:
+${config.context}
+
+` : ''}${config.keywords && config.keywords.length > 0 ? `KEYWORDS:
+${config.keywords.join(', ')}
+
+` : ''}CONTENT REQUIREMENTS:
+- Generate ${config.length} content appropriate for ${config.promptType}
+- Use ${config.tone} tone throughout the text
+- Follow conventions for ${config.promptType} writing
+- Write fluently in ${config.language}
+
+STYLE GUIDELINES:
+${this.getStyleGuidelines(config)}
+
+GENERATION PARAMETERS:
+- Temperature: ${getTemperature(config.promptType, config.tone)} (creativity level)
+- Max Tokens: ${this.estimateTokens(config)} (content length)
+- Top-P: ${getTopP(config.promptType)} (nucleus sampling)
+- Frequency Penalty: ${config.tone === 'formal' ? 0.3 : 0.1} (repetition reduction)
+- Presence Penalty: ${config.promptType === 'creative' ? 0.2 : 0.1} (new topic encouragement)
+
+EXPECTED OUTPUT:
+Professional ${config.promptType} content in ${config.language},
+approximately ${this.estimateTokens(config)} tokens long,
+with ${config.tone} tone and appropriate style.
+      `.trim(),
+      variables: [],
+      safety: {
+        contentFilter: true,
+        adultContentFilter: true,
+        violenceFilter: true,
+        hateSpeechFilter: true,
+        copyrightFilter: true,
+      },
+      version: '1.0.0',
+    });
+  }
+
+  private getStyleGuidelines(config: TextGenerationConfig): string {
+    const guidelines: string[] = [];
+
+    switch (config.promptType) {
+      case 'creative':
+        guidelines.push('- Use imaginative and engaging language');
+        guidelines.push('- Incorporate vivid descriptions and storytelling');
+        break;
+      case 'technical':
+        guidelines.push('- Use precise terminology and clear explanations');
+        guidelines.push('- Maintain logical structure and accuracy');
+        break;
+      case 'marketing':
+        guidelines.push('- Use persuasive and compelling language');
+        guidelines.push('- Include clear calls to action');
+        break;
+      case 'educational':
+        guidelines.push('- Present information clearly and progressively');
+        guidelines.push('- Include examples and explanations');
+        break;
+      case 'conversational':
+        guidelines.push('- Use natural, approachable language');
+        guidelines.push('- Include questions and engagement elements');
+        break;
+    }
+
+    switch (config.tone) {
+      case 'formal':
+        guidelines.push('- Maintain professional and respectful language');
+        guidelines.push('- Use proper grammar and complete sentences');
+        break;
+      case 'casual':
+        guidelines.push('- Use relaxed, natural language');
+        guidelines.push('- Include some conversational elements');
+        break;
+      case 'friendly':
+        guidelines.push('- Use warm and approachable tone');
+        guidelines.push('- Include encouraging and positive elements');
+        break;
+      case 'humorous':
+        guidelines.push('- Incorporate appropriate humor and wit');
+        guidelines.push('- Maintain lighthearted and engaging style');
+        break;
+    }
+
+    return guidelines.join('\n') || '- Follow standard writing conventions';
+  }
+}

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;
+};